Sommaire

Résumé de cours.........................................................................................................................3
Exercices...................................................................................................................................20
Solution.....................................................................................................................................32
Exercice 1..............................................................................................................................33
Exercice 2..............................................................................................................................35
Exercice 3..............................................................................................................................38
Exercice 4..............................................................................................................................40
Exercice 5..............................................................................................................................42
Exercice 6..............................................................................................................................45
Exercice 7..............................................................................................................................47
Exercice 8..............................................................................................................................49
Exercice 9..............................................................................................................................53
Exercice 10............................................................................................................................56
Exercice 11............................................................................................................................58
Exercice 12............................................................................................................................62
Exercice 13............................................................................................................................64
Exercice 14............................................................................................................................67
Exercice 15............................................................................................................................71
Exercice 16............................................................................................................................74
Exercice 17............................................................................................................................77
Exercice 18............................................................................................................................79
Exercice 19............................................................................................................................81
Exercice 20............................................................................................................................84
Exercice 21............................................................................................................................86
Exercice 22............................................................................................................................87
Exercice 23............................................................................................................................89
Exercice 24............................................................................................................................90
Exercice 25............................................................................................................................93
Exercice 26............................................................................................................................96
Exercice 27............................................................................................................................99
Exercice 28..........................................................................................................................102
Exercice 29..........................................................................................................................103
Exercice 30..........................................................................................................................112

1 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 31..........................................................................................................................115
Exercice 32..........................................................................................................................118
Exercice 33..........................................................................................................................124
Exercice 34..........................................................................................................................127
Exercice 35..........................................................................................................................130
Exercice 36..........................................................................................................................133
Exercice 37..........................................................................................................................137
Exercice 38..........................................................................................................................141
Exercice 39..........................................................................................................................144
Exercice 40..........................................................................................................................146

2 Bac Scientifique Idoudi Khaled Enseignant :

 Résumé de cours

3 Bac Scientifique Idoudi Khaled Enseignant :

 Les opérateurs arithmétiques et leur priorités

Soit l’opération suivante: res = A + B res avec

: résultat
A et B : opérandes
opérateur : +

Priorité Opérateur
Désignation de Type des
des En
l’opération En Pascal opérandes
opérateurs algorithmique
Parenthèses 1 (…) (…) Tout type
Entier ou
Multiplication x *
réel
Division réelle / / Réel
Division entière DIV DIV Entier
2
Reste de la
MOD MOD Entier
division entière
Entier ou
Addition + +
réel
3 Entier ou
Soustraction - -
réel
Tout type
Egale = =
ordonné
Tout type
Différent ≠ <>
ordonné
Tout type
Inférieur < <
ordonné
Tout type
Supérieur > >
4 ordonné
Inférieur ou Tout type
≤ <=
égale ordonné
Supérieur ou Tout type
≥ >=
égale ordonné
Type
L’appartenance 5 DANS IN
scalaire

Remarque: les opérateurs de même niveau de priorité seront évalués

de gauche vers la droite (vous pouvez utiliser les parenthèses pour
modifier l’ordre d’évaluation des expressions).

4 Bac Scientifique Idoudi Khaled Enseignant :

 Les fonctions arithmétiques standards

Syntaxe
Syntaxe en Type Type de
en Rôle de la fonction Exemples
algorithme de x résultat
Pascal

Entier Même R:=ABS(-6);R=6

Retourne la valeur
Abs (x) ABS (x) ou type que R:=ABS(-7.5);
absolue de x.
réel x R= 7.5

R:=ARCTAN(1);
Retourne la valeur
ARCTAN R= PI/4
Arctan (x) en radians de l’arc Réel Réel
(x) R:=ARCTAN(0.48);
tangente de x.
R=PI/6

R:=ROUND(7.4);R=7
ROUND Retourne l’entier le
Arrondi (x) Réel Entier R:=ROUND(7.5);R=8
(x) plus proche de x.
R:=ROUND(7.9);R=8

Entier Même R:=SQR(3);R=9

Retourne le carré de
Carré (x) SQR (x) ou type que R:=SQR(3.5);
x.
réel x R=12.25

Retourne le cosinus R:=COS(PI/2);R= 0

Cos (x) COS (x) Réel Réel
de x (x en radians). R:=COS(PI);R= -1

Retourne R:=EXP(1);R= 2.72

Exp (x) EXP (x) l’exponentielle de Réel Réel R:=EXP(-3.5);R=
x. 0.03
Retourne le
logarithme népérien
R:=LN (1);R= 0
Ln (x) LN (x) de x si x est Réel Réel
R:=LN(3.5);R=1.25
positif sinon il
provoque une erreur.
Retourne la racine
R:=SQRT(4); R= 2
RacineCarré carré de x si x est
SQRT(x) Réel Réel R:=SQRT(20.45);
(x) positif sinon il
R= 4.52
provoque une erreur.

Retourne le sinus de R:=SIN(PI/2);R= 1

Sin (x) SIN (x) Réel Réel
x (x en radians) R:=SIN(PI); R= 0

Retourne un entier, R:=TRUNC(-1.5);

TRUNC en ignorant la R=-1
Tronc (x) Réel Entier
(x) partie décimale de R:=TRUNC(9.5);
Les fonctions standard sur les caractères
x. R= 9

5 Bac Scientifique Idoudi Khaled Enseignant :

Syntaxe en Syntaxe Rôle de la Type de Type de
Exemples
algorithme en Pascal fonction paramètre résultat
R := CHR (65) ;
Retourne le
R sera égal à 'A'
CHR (N) CHR (N) caractère dont le Entier Caractère
R := CHR (97) ;
code ASCII est N.
R sera égal à 'a'
R := ORD ('D') ;
Retourne le code
R sera égal à 68.
ORD (C) ORD (C) ASCII du Caractère Entier
R := ORD ('0') ;
caractère C.
R sera égal à 48.
Retourne le N :=PRED (4) ;
prédécesseur de C Même type N sera égal à 3.
PRED (C) PRED (C) Scalaire
(c’est à dire qui de C R :=PRED ('D') ;
précède C). R sera égal à 'C'
Retourne le N := SUCC (3) ;
successeur de C Même type  N sera égal à 4.
SUCC (C) SUCC (C) Scalaire
(c’est à dire qui que C R:= SUCC ('C');
suit C). R sera égal à 'D'
Convertir le R:= UPCASE ('e');
caractère C en R sera égale à E'.
MAJUS (C) UPCASE (C) Caractère Caractère
majuscule s’il R:= UPCASE ('F');
est possible. R sera égale à 'F'

Syntaxe en Syntaxe en Rôle de la fonction Exemples

algo Pascal
Long (ch) LENGTH (ch) Retourne un entier
représentant la L:=LENGTH('Algorithme'); L= 10
longueur de la chaîne L:=LENGTH(' Pascal'); L= 7
ch.
Concat CONCAT(ch1, Retourne une chaîne CH:=CONCAT('micro-','ordinateur')
(ch1, ch2, ch2, …,chn) qui est la somme de ;
…, chn) plusieurs chaînes CH= 'micro-ordinateur'
dans l’ordre. CH:=CONCAT('Turbo',' ','Pascal');
CH= 'Turbo Pascal'
Sous_chaîne COPY Retourne une sous- CH:=COPY('Baccalauréat',1,3) ;
(ch,p,n) (ch,p,n) chaîne de longueur N CH= 'Bac'
à partir de la CH:=COPY('micro-
position p dans ch. ordinateur',7,10);
CH= 'ordinateur'
Pos POS Retourne un entier
(ch1,ch2) (ch1,ch2) représentant la
position de la P:=POS('m','programmation');P= 7
première occurrence P:=POS('r','programmation');P= 2
Les fonctions standard sur les chaînes de
de la chaîne ch1. Si P:=POS('R','programmation');P= 0
ch1 n’est pas dans
caractères
ch2, elle retourne 0.
Les procédures standard sur les chaînes de caractères

6 Bac Scientifique Idoudi Khaled Enseignant :

 Syntaxe Syntaxe en
Rôle de la fonction Exemples
en algo Pascal
Enlève n caractères CH :='programmation' ;
Efface DELETE de la chaîne ch à delete('programmation',
(ch,p,n) (ch,p,n)
partir de la position 8,6);
p. CH= 'program'
Insère la chaîne ch1
dans la chaîne ch2 à
CH1 := '-' ;
Insérer INSERT partir de la position
CH2 := 'Hautparleurs'
(ch1,ch2, (ch1,ch2,p p. Le caractère n°p
INSERT (CH1,CH2,5) ;
p) ) et les suivants
CH2= 'Haut-parleurs'
seront décalés vers
la droite.
STR (2002, CH) ;
Convertit une valeur
CH= '2002'
numérique en une
Convch STR (15.54, CH) ;
STR (n,ch) chaîne de caractères
(n,ch) CH=
et l’affecte à la
'1.5540000000E+01'
variable ch.
Convertit une chaîne
VAL ('2003',n,pe) ;
ch en une valeur
 n= 2003 et pe=0
numérique et
VAL('06/08/1970',
Valeur l’affecte à la
VAL n,pe) ;
(ch,n, variable n. Le
(ch,n, pe)  n= 0 et pe= 3
pe) paramètre pe est une
(le caractère / n’est
variable entière qui
pas un chiffre).
contiendra la
position de l’erreur.

Les structures simples

Affectation
Analyse Algorithmique Pascal
Variable  expression Variable := expression ;
Exemple Exemple
A  8 A := 8
A  3*5/2 A := 3*5/2
A  B A := B
A  3 < 5 A := 3 < 5
Opération d’entrée
Analyse Algorithmique Pascal
Variable=donnée("Message") Ecrire("Message") Write('Message') ;
Lire(Variable) Read(Variable) ; ou
Exemple Exemple Readln(Variable) ;
a = Donnée ("Donner la Ecrire("Donner la Exemple
valeur de a") valeur de a") Write('Donner la valeur de a');

7 Bac Scientifique Idoudi Khaled Enseignant :

 Lire(a) Readln(a) ;
Opération de sortie
Analyse Algorithmique Pascal
Ecrire("Message") Write('Message');
Affichage d’un Exemple ou Writeln('Message') ;
texte Ecrire("Donner la valeur de Exemple
(message) a") Writeln('Donner la valeur de
a') ;
Ecrire(variable) write(variable); ou
Affichage de Exemple Writeln(variable) ;
contenu d’une
Ecrire(variable) Exemple
variable
writeln(variable) ;
Ecrire("Message",variable) write('Message',variable); ou
Affichage d’un Exemple Writeln('Message', variable);
texte et d’une
Ecrire("Le produit est", P) Exemple
variable
writeln(‘Le produit est’, P) ;

Les structures conditionnelles

La forme simple réduite

Analyse Algorithmiqu Pascal
e

Si condition alors If condition then

Traitement Traitement ;
FinSi

La forme alternative
Analyse Algorithmique Pascal
Si condition alors If condition then
Instruction 1.1 Begin
Instruction 1.2 Instruction 1.1 ;
……………. Instruction 1.2 ;
Instruction 1.n …………….
Sinon Instruction 1.n ;
Instruction 2.1 End
Instruction 2.2 Else
……………. Begin
Instruction 2.n Instruction 2.1 ;
FinSi Instruction 2.2 ;
…………….

8 Bac Scientifique Idoudi Khaled Enseignant :

 Instruction 2.n ;
End ;
La forme généralisée
Analyse Algorithmique Pascal
[init] Init;
Si condition 1 alors traitement 1 IF condition1 THEN traitement1
Sinon Si condition 2 Alors traitement 2 ELSE IF condition2 THEN
Sinon Si condition 3 Alors traitement 3 traitement2
………….. ELSE IF condition3 THEN
………….. traitement3
Sinon Si condition n-1 Alors traitement …………..
n-1 …………..
Sinon traitement n ELSE IF condition n-1 THEN
FinSi traitement n-1
ELSE traitement n ;
La structure de contrôle conditionnelle à choix
Analyse Algorithmique Pascal
[init] Init;
Selon sélecteur Faire Case sélecteur OF
Valeur_1 : traitement 1 Valeur_1 : traitement 1 ;
Valeur_2 : traitement 2 Valeur_2 : traitement 2 ;
Valeur_3 : traitement 3 Valeur_3 : traitement 3 ;
……… ………
Valeur_n : traitement n Valeur_n : traitement n ;
Sinon traitement n+1 else traitement n+1 ;
Fin selon End ;

9 Bac Scientifique Idoudi Khaled Enseignant :

 Définition itérative
Définition itérative à condition d’arrêt
complète
Formulation 1 Formulation 2
Résultat=[ init] Résultat=[init]
Pour compteur de Vi à Vf faire Résultat = [ Init ]
Répéter
Analyse Traitement Tant que(Non(Cond_arrêt) faire
Traitement
Fin Pour Traitement
Jusqu’à (Condition arrêt)
Fin tant que
Forme
…..; ….. ;
Générale …. ;
….. ;
…… ;
…… ;
For compteur : = Vi To Vf Do While ( Not(cond_arrêt)) Do
Repeat
Pascal Begin
…… ;
Begin
….. ; …… ;
……. ;
….. ; ……. ;
Until(condition arrêt);
End ; End ;
Compteur de type scalaire
Types discret
(Entier / caractère)
Connu d’avance
Inconnue
Pour les entiers :
Inconnu Si la condition d’arrêt est
Nombre d’itération Vf – Vi + 1
Au moins une fois vraie, la boucle ne s’exécute
Pour les caractères :
jamais.
Ord ( Vf) – Ord (Vi) + 1

Initialisation Le compteur est initialisé à Les variables qui figurent dans l’expression de la
Vi condition doivent être initialisées par l’utilisateur.
& L’incrémentation automatique Elles doivent être modifiées à l’intérieur de la boucle,
incrémentation
Les structures itératives: les boucles
se fait de 1 sinon le boucle ne s’arrête pas. (Boucle infini).

10 Bac Scientifique Idoudi Khaled Enseignant :

 Vocabulaire et syntaxe d'une fonction

Au niveau de la définition (la création et la rédaction) d’une fonction:

 En analyse
DEF FN nom_de_fonction(pf1,pf2,…:typeI;pf’1,pf’2,…:typeII ;…):type-
résultat
Résultat = nom_de_fonction
nom_de_fonction  R
…..
Fin nom_de_fonction
Remarque :
pf1,pf2,… : Paramètres formels
type-résultat: Résultat à chercher dans le bloc du module doit être
de type simple (entier, réel, caractère, booléen, chaine de
caractère). Une fonction ne peut pas retourner un tableau ou deux
entiers par exemple.
R: étant le résultat de la fonction qui doit être de même type ou de
type compatible que la fonction.

 En algorithme
0) DEF FN nom_de_fonction(pf1,pf2,… : typeI; pf'1,pf'2,… :typeII ;…):
type-résultat
1) … <traitement>
…..
n-1) nom_de_fonction  R
n) FIN nom_de_fonction
 En Pascal
FUNCTION nom_de_fonction (pf1,pf2,…:typeI;pf'1,pf'2,…: typeII;):type-
résultat;
Const = ……..; {constantes locales}
Type = ……….; {types locaux}
Var …….; {variables locales}
Begin
……. <traitement>
………
nom_de_fonction := R;
End;
Au niveau de l’appel :
Une fonction peut être appelée à partir:
 du programme principal
 d’un autre sous-programme (module)
Une fonction peut être appelée de quatre manières

Paramètres effectifs
11 Bac Scientifique Idoudi Khaled Enseignant :
  Dans une instruction d'affectation:
MFN nom_de_fonction(pe1,pe2,…,pe’1,pe’2,…)
 Dans une instruction de sortie (écriture) :
Ecrire(FN nom_de_fonction(pe1,pe2,…,pe’1,pe’2,…))
 Dans une instruction conditionnelle :
Si (FN nom_de_fonction(pe1,pe2,…,pe’1,pe’2,…)=Y) alors ..
 Dans une expression arithmétique :
Y  2+FN nom_de_fonction(pe1,pe2,…,pe’1,pe’2,…)

RETENONS: Les paramètres formels doivent s’accorder du point de vue

nombre, ordre et types compatibles avec les paramètres effectifs.

12 Bac Scientifique Idoudi Khaled Enseignant :

 Vocabulaire et syntaxe d'une procédure

Au niveau de la définition (la création et la rédaction) d’une Procédure :

 En analyse
DEF PROC nom_de_procédure(pf1,pf2,… :typeI ; pf1,pf2,… :typeII ;…)
Résultat = ……
<traitement>
…..
Fin nom_de_procédure
Remarque : pf1,pf2,… : Paramètres formels
 En algorithme
0) DEF PROC nom_de_procédure(pf1,pf2,…:typeI ; pf1,pf2,…: typeII;
…)
1) <traitement>
………..
n) FIN nom_de_procédure
 En Pascal
PROCEDURE nom_de_procédure (pf1,pf2,… :typeI ; pf'1,pf'2,… :typeII ;
…);
Const = ……..; {constantes locales}
Type = ……….; {types locaux}
Var …….; {variables locales}
Begin
…<traitement>
End;
Au niveau de l’appel :
Une procédure peut être appelée à partir:
 du programme principal
 d’un autre sous-programme (à condition qu’il soit déclaré à
l’intérieur de ce sous-programme ou avant)
Paramètres effectifs

PROC nom_de_procédure (pe1,pe2,…,pe1,pe2,…)

RETENONS: Les paramètres formels doivent s’accorder du point de vue

nombre, ordre et types compatibles avec les paramètres effectifs.

Les algorithmes avancées

13 Bac Scientifique Idoudi Khaled Enseignant :

 Tri par sélection:
 Principe
On recherche le plus petit (ou le plus grand) élément et on
l'extrait, on recherche ensuite le plus petit des éléments qui
restent et on l'extrait et on recommence ainsi jusqu'à ce que l'on
ait extrait tous les éléments.
 Méthode
1. Sélectionner le premier élément du tableau
2. Parcourir le reste du tableau à la recherche de l’élément
ayant la plus petite valeur.
3. Si le cas est présent permuter les deux éléments
4. Incrémenter le premier indice
5. Refaire les étapes 2, 3, et 4 jusqu'à la fin du tableau.
 Exemple: Trier dans l'ordre croissant le tableau suivant:

T 15 12 5 1 9
i=1 p = 4
1 12 5 15 9
i=2 p = 3
1 5 12 15 9
i=3 p = 5
1 5 9 15 12
i=4 p = 5
1 5 9 12 15
 Algorithme:
0) DEF PROC Tri_selection (var T : tab ; n : entier)
1) pour i de 1 à n-1 faire
[posmin← i ] pour j de i+1 à n faire
si T[j]< T[posmin] alors
posmin← j
fin si
fin pour
si posmin <> i alors
aux T[i]
T[i] T[posmin]
T[posmin]aux
Fin si
Fin pour
2) Fin trier
Tri à bulle
 Principe

14 Bac Scientifique Idoudi Khaled Enseignant :

 A chaque étape on considère un couple d'éléments; s'ils ne sont
pas dans le bon ordre l'un par rapport à l'autre, on les permute; on
répète ce procédé en changeant de couple et ce, jusqu'à ce que plus
aucun échange ne soit nécessaire.
 Méthode
On effectue des passages successif sur le tableau on examinent les
éléments du tableau par paire V[i] et V[i+1] et on échange les
valeurs si V[i]>V[i+1], chaque passage s'arrête au niveau du dernier
échange du passage précédent ainsi le 1ér passage est allé jusqu'à
V[N]. On arrête les passages dés que l'un d'entre eux n'entraîne
aucun échange.
 Exemple
Trier dans l'ordre croissant le tableau suivant:
T 15 3 5 1 10
i=1 i+1=2
3 15 5 1 10
i=2 i+1=3
3 5 15 1 10
i=3 i+1=4
3 5 1 15 10
i=4 i+1=5
3 5 1 10 15
i=1 i+1=2
3 5 1 10 15
i=2 i+1=3
3 1 5 10 15
i=3 i+1=4
3 1 5 10 15
i=4 i+1=5
3 1 5 10 15
i=1 i+1=2
1 3 5 10 15
i=2 i+1=3
1 3 5 10 15
i=2 i+1=3
1 3 5 10 15
i=1 i+1=2
 Algorithme:
0) DEF PROC Tri_bulle (var T : tab ; n : entier)
1) Répéter

15 Bac Scientifique Idoudi Khaled Enseignant :

 [Echangefaux] pour i de 1 à n-1 faire
Si (T[i]>T[i+1]) alors
aux T[i]
T[i] T[i+1]
T[i+1]aux
Echange vrai
Fin Si
Fin pour
nn-1
Jusqu’à (n=1) ou non(Echange)
2) Fin trier

Tri par insertion

 Principe
On ne considère qu'un seul élément à la fois et on essaye de
l'insérer en position correcte par rapport à un sous-ensemble
d'éléments précédemment triés: le tri se terminera lorsque tous les
éléments auront été insérés.
 Méthode
1. On commence par le deuxième élément
2. Tant que l’élément précèdent supérieur à l’élément
sélectionner on le décale à droite
3. On insert l’élément sélectionner en position correcte
4. on sélectionne l’élément suivant
5. On répète les étapes 2, 3 et 4 jusqu’au dernier élément du
tableau.
 Algorithme:
0) DEF PROC Tri_insertion(N : Entier ; Var T : Tab)
1) pour i de 2 à n faire
aux ß T[i]
jß i
Tant que (T[j-1]>aux) faire
T[j]T[j-1]
jj-1
Fin Tant que
T[j]aux
2) Fin Tri_insertion

 Exemple: Trier dans l'ordre croissant le tableau suivant:

T 15 3 5 1 10 3 < 15 alors décalage de 15 vers

16 Bac Scientifique Idoudi Khaled Enseignant :

 i = 2 la droite et insertion de 3 dans
sa place
3 15 5 1 10 5 > 3 mais 5 < 15 alors décalage
de 15 vers la droite et insertion
i = 3 de 5 dans sa place
3 5 15 1 10 1 < 3 alors décalage de 3, 5 et
15 vers la droite et insertion de
i = 4 1 dans la place de 3
1 3 5 15 10 10 < 15 alors décalage de 15 vers
la droite et insertion de 10 dans
i = 5 sa place
1 3 5 10 15

Recherche dichotomique
Principe
Cette méthode de recherche est applicable uniquement sur une liste
préalablement triée. Le principe de cette méthode consiste à réduire
à chaque fois l’espace de recherche sur la moitié de la liste. Le
choix de l’une des deux parties dans laquelle se trouve la valeur
cherchée est le résultat de l’évaluation d’un test. A chaque
évaluation, on coupera l’espace de recherche en deux parties égales
(à un élément près) de part et d’autre de l’élément médiane.
Exemple
Valeur chercher: Vc= 15
V 1 3 7 12 15 16
Médian=(1+6) div 2 = 3
V[médian] = 7 < Vc médian=(4+6) div 2 = 5
A rejeter 1 3 7 12 15 16
V[médian] = 15 = Vc

 Algorithme:
0) DEF FN Recherche (A: TAB ; n, Vc : entier) : chaîne
1) [g 1,d n] répéter
m (g+d) div2

17 Bac Scientifique Idoudi Khaled Enseignant :

 Si y<A[m] alors
d m-1
Sinon
g m+1
Fin Si
jusqu’à (Vc=A[m]) ou (g>d)
2) si (y=A[m] ) alors
Recherche  “existe“
Sinon
Recherche “non existe“
Fin si
3) Fin recherche

Structure Générale d'un Programme Pascal

18 Bac Scientifique Idoudi Khaled Enseignant :

 PROGRAM Nom_programme ;
Uses wincrt ;
Const {déclaration des constantes} ;
Type {déclaration des types de données} ;
Var {déclaration des variables globales} ;

PROCEDURE Nom_Procédure (paramètres formels) ;

{Déclarations locales}
Begin
Instructions de la procédure ;
End ; {fin de la procédure}

FUNCTION Nom_Fonction (paramètres formels):type ;

{Déclarations locales}
Begin
Instructions de la fonction ;
Nom_Fonction := Résultat ;
End ; {fin de la fonction}

BEGIN {début du Programme Principal}

{Bloc principal du programme avec appel des

procédures et des fonctions}

END. { fin du P.P }

Remarques:
1. l'ordre de l'écriture des sous programmes n'est pas important,
à l'exception ou un module utilise un autre module; dans ce cas
il faut que le programme appelé soit écrit avant le programme
appelant
2. un module ne s'exécute jamais s'il n'a pas été appelé par le
programme principal

19 Bac Scientifique Idoudi Khaled Enseignant :

 Exercices
Questions demandées pour tous les exercices :

❶ Analyser ce problème en décomposant en modules.

❷ Analyser chacun de ces modules.
❸ En déduire l’algorithme de résolution relatif à chacun de
ces modules ainsi que celui du programme principal.
❹ Traduire les algorithmes obtenus en Pascal

20 Bac Scientifique Idoudi Khaled Enseignant :

1 2
Un entier naturel est dit Soit un tableau T1 de N1
parfait s’il est égal à la somme éléments (1N1100). Les éléments
de tous ses diviseurs autres que de T1 sont des entiers naturels
lui-même. de trois chiffres.
Exemple : On se propose de remplir et
6 est dit un nombre parfait car il afficher un tableau T2 de la
vérifie 6 = 1 + 2 + 3 où 1,2 et 3 façon suivante :
sont les diviseurs de 6 autres que T2[i] est égal à la somme des
6. carrés des chiffres de T1[i].
On se propose de chercher tous les Exemple :
entiers parfaits compris entre Si T1[i] = 254 alors
deux valeurs données m et n telles T2[i] = 2 + 5 +42 = 45
2 2

que 2mn.

3 4
Un entier naturel est dit On se propose d'élaborer un
palindrome s’il est lu de la programme qui permet de calculer
même façon de gauche à droite et la somme factorielle des chiffres
de droite à gauche. de tous les entiers de
Exemple : 121 est un entier l'intervalle [10..50], en les
impair et palindrome. sauvegardant dans un vecteur T.
On cherche à afficher les N Exemple: Si l'entier égale à 14
premiers entiers naturels alors la valeur 25 sera stoker
positifs impairs et palindromes dans T (car 1! + 4! = 25).
(N étant un entier naturel tel Enfin afficher i fois le contenu
que 5  N  20). de la case n° i (pour chaque case
du tableau), en commençant par le
dernier élément du vecteur T.

5 6
24 est un entier divisible par
Elaborer un programme qui permet son chiffre des dizaines (2).
de saisir un vecteur T par n
chaînes de caractères (4< n <20), Elaborer un programme permettant
cherche et affiche la longueur de de trouver et sauvegarder dans
la chaîne la plus longue puis un vecteur V tous les entiers à
affiche toutes les chaînes ayant deux chiffres vérifiant cette
cette longueur. propriété, puis afficher les
éléments de ce dernier : les
éléments d'indice pair suivi par
ceux d'indice impair.

21 Bac Scientifique Idoudi Khaled Enseignant :

7 8

Ecrire un programme Pascal

intitulé PROD_SCALAIRE qui permet On appelle moyenne olympique d’un
de calculer et d’afficher le ensemble de nombres la moyenne
produit scalaire de deux tableaux arithmétique de tous les nombres
A et B de n entiers positifs ( n de cet ensemble sauf le plus petit
étant un entier compris entre 5 et et le plus grand.
50). Ecrire un programme Pascal
N.B : Le produit scalaire de deux permettant de saisir un tableau de
tableaux A et B est donné par la N réels (5≤ N ≤20) distincts et
formule suivante : d’afficher leur moyenne olympique.
n
PS =∑ A [ i ] *B [ i ]
i=1

9 10

Ecrire un programme qui permet de

Ecrire un programme permet de lire saisir une chaîne de caractères
CH1 puis d’en extraire les deux
un code d’ADN sous forme d’un
nombres formés par les chiffres
tableau D de n caractères (5n figurant dans la chaîne CH 1
30). Puis déterminer et afficher (extraction à partir de la droite
puis extraction à partir de la
le code d’ARN (sous forme d’un
gauche).
tableau R) correspondant. Sachant Exemple : Si CH1= "A45B3C2"
que le code d’ADN utilise les Le programme Pascal affichera 4532
et 2354
lettres A, T, C et G et le code
ARN correspondant est obtenu par
correspondance de base :
11
AU TA CG GC
Ecrire un programme Pascal qui
permet d’insérer un entier X dans
un tableau trié T en conservant le
Exemple : (pour n = 5) tableau trié.
1 2 3 4 5 Sachant que T et de N entiers (5 
D (tableau ADN) T A C G T
N  30 )
1 2 3 4 5 NB: La solution doit comporter au
R (tableau ARN) A U G C A moins une fonction et une
procédure.

22 Bac Scientifique Idoudi Khaled Enseignant :

12
Ecrire un programme pascal qui permet de saisir une chaîne non vide
de longueur impaire et de l'afficher sous la forme d'un sablier
Exemples:
Ch="ECRAN" Ch ="SABLIER"
N A R C E R E I L B A S
A R C E I L B A
R I L B
A R C L
N A R C E I L B
E I L B A
R E I L B A S

13 14
Ecrire un programme qui saisit
Soit un tableau T de 20 entiers
une phrase et l’affiche renversée.
positifs. Ecrire un programme qui
La phrase commence,
permet d’afficher les éléments de
obligatoirement, par une lettre et
T compris entre deux positions P1
ses mots sont séparés par un seul
et P2, leur moyenne arithmétique,
espace et ne se termine pas par un
la valeur maximale et la valeur
espace.
minimale contenues dans cet
Exemple :
intervalle. On donne 1 ≤P1 < P2 ≤
Votre phrase:"RESOLUTION DE
20.
PROBLEMES"
Résultat:"PROBLEMES DE RESOLUTION"

15 16
Soit un tableau T1 contenant Ecrire un programme qui permet
n lettres majuscules (de A à Z). de trier par ordre décroissant les
n étant un entier compris entre 5 éléments d’un tableau A de n
et 20. entiers positifs dans un nouveau
On désire trier en ordre croissant
tableau B de même dimension.
les éléments de T1 et les ranger
dans un tableau T2 en utilisant le N étant un entier vérifiant
principe suivant : 5 < n < 25.
1. Chercher la lettre qui a le On utilisera la démarche suivante:
plus petit code ASCII dans T1 1. chercher le maximum de A
2. 2. placer ce maximum dans B
a) Ranger cette lettre dans T2
3. remplacer le maximum par -1
b) Remplacer cette lettre par "*"
dans T1 dans A
3. Répéter n fois l’étape 1. et 2. 4. refaire l’étape 1, 2 et 3
Ecrire un programme Pascal qui jusqu’à ce que le tableau A soit
permet de : entièrement composé de -1.
 Saisir les éléments de T1. N.B : Prévoir l’affichage des
 Trier les éléments de T1 et éléments du tableau B
les ranger dans T2.
 Afficher les éléments de T2.

23 Bac Scientifique Idoudi Khaled Enseignant :

17 18
Deux entiers naturels strictement Ecrire un programme qui réalise le
positifs m et n sont dits nombre traitement suivant :
amis si et seulement si :  choisir un entier n de
 la somme des diviseurs de m l’intervalle [100, 500] et un
sauf lui-même est égale à n
entier m de l’intervalle
 et la somme des diviseurs de n
sauf lui-même est égale à m. [10,99]
Exemple :  afficher tous les entiers de
220 et 284 sont deux nombres amis. l’intervalle [1, m] en
En effet : remplaçant par le caractère
D284 = {1, 2, 4, 71, 142, 284} "*" tous les diviseurs de n
D220 = {1, 2, 4, 5, 10, 11, 20,
ainsi que tous les entiers
22, 44, 55, 110, 220}
D284 et D220 sont respectivement comportant dans leurs
les ensembles de tous les écritures le chiffre des
diviseurs de 284 et de 220. unités de n.
284 = 1 + 2 + 4 + 5 + 10 + 11 + 20 Exemple d’exécution :
+ 22 + 44 + 55 + 110 Si n = 100 et m = 20 alors la
220 = 1 + 2 + 4 + 71 + 142 liste suivante sera affichée :
Écrire un programme qui permet de
* * 3 * * 6 7 8 9 * 11 12 13 14 15
déterminer puis d’afficher si deux
entiers naturels donnés m et n 16 17 18 19 *
sont amis ou non.

19 20
On se propose d’écrire un On veut écrire un programme
programme permettant de déterminer permettant de coder un message
et d’afficher la lettre selon le procédé suivant :
alphabétique la plus utilisée dans permuter chaque caractère d’indice
un texte donné. Le texte étant pair avec le caractère qui le
saisi comme une chaîne de précède.
caractères contenant n de Exemple :
caractères (5 ≤ n ≤20). Le codage de la chaîne de
Dans le cas d’ex-aequo, afficher caractère: "Baccalauréat" donne
toutes les lettres ayant la plus "aBcclauaérta"
grande fréquence.

21
Deux joueurs lancent en même temps un dé dont les faces sont numérotées
de 1 à 6. Le joueur qui obtiendra la plus grande valeur aura un point. Le
jeu s’arrête quand l’un des joueurs arrive le premier à un score de 10
points.
Ecrire un programme Pascal simulant ce jeu et afficher le numéro du joueur
gagnant.
On pourra utiliser la fonction prédéfinie RANDOM (n) qui retourne un entier
de l’intervalle [0, n – 1].

24 Bac Scientifique Idoudi Khaled Enseignant :

22 23
On veut écrire un programme Ecrire un programme qui saisit
permettant de lire un mot intitulé une chaîne de caractères de
CHM composé au moins de 5 longueur minimal 3 et l’affiche
caractères et d’afficher les sous la forme d’un triangle comme
chaînes de caractères suivantes : indiqué ci-dessous.
 La chaîne formée par le Exemple :
premier et le dernier Si la chaîne saisie est
caractère de CHM "INTERNET", on aura :
 La chaîne formée par les deux I
premiers et les deux derniers IN
caractères de CHM INT
INTE
 Etc.
INTER
Exemple : Si la chaîne CHM INTERN
contient "TURBO" alors le INTERNE
programme affichera : INTERNET
TO
TUBO 25
TURRBO
TURBURBO Ecrire un programme qui permet de
TURBOTURBO
Remplir un tableau T de n (3≤n≤20)
24 éléments de types caractères,
On se propose de réaliser le inverser le contenu du tableau puis
traitement suivant sur une chaîne
CH : afficher le résultat.
Construire une chaîne RES à partir
de la chaîne CH dans laquelle on
rangera toutes les consonnes de CH
qui sont en majuscule, suivies de 26
toutes les voyelles de CH qui sont Ecrire un programme qui permet
en majuscule, suivies de toutes les
de saisir un entier positif N,
consonnes de CH qui sont en
minuscule et finalement toutes les composé de trois chiffres, de
voyelles de CH qui sont en déterminer et d’afficher tous les
minuscule en conservant à chaque nombres qui peuvent être formés par
fois le même ordre d'apparition des les chiffres de N, ainsi que le
lettres de la chaîne CH. plus petit et le plus grand de ces
Ecrire un programme qui permet de nombres.
saisir une chaîne CH non vide
Exemple :
composée de lettres alphabétiques
et dont la taille ne dépasse pas 50 Pour N = 427, le programme
et de construire puis d'afficher la affichera :
chaîne RES. Les nombres formés par les chiffres
Exemple: de 427 sont : 427, 472, 724, 742,
Si CH = "aFAbzKOikvMx" Alors le 247, 274
programme affichera la chaîne Le plus petit nombre est 247
"FKMAObzkvxai"
Le plus grand nombre est 742

25 Bac Scientifique Idoudi Khaled Enseignant :

 27

On se propose d’écrire un programme permettant de vérifier si un entier

donné est subline ou non. Un entier est dit sublime si la somme de ses
diviseurs y compris lui-même et le nombre de ses diviseurs sont deux
nombres parfaits.
Un entier est dit parfait s'il est égal à la somme de ses diviseurs
sauf lui-même
Exemple: N=12
la somme des diviseurs SD de 12 est 1+2+3+4+6+12=28
le nombre de diviseurs NBD de 12 est 6
on a
 28 est parfait car 28=1+2+4+7+14
 6 est parfait car 6=1+2+3
=>donc 12 est sublime
On propose les algorithmes suivants:
0)Def fn parfait (m:entier):booléen 0)Début sublime
1)Somd<-1 1)Ecrire ("N=")
Pour i de 2 à (m div 2) faire Lire (N)
Si (m mod i)=0 alors 2)Proc diviseurs(N, SD, NBD)
Somdsomd+i 3)Proc affiche (N, SD, NBD)
Fin si 4)Fin sublime
Fin pour
2)parfait(somd=m)
3)Fin parfait

Questions:
1.écrire la procédure "diviseurs" permettant de calculer la somme S des
diviseurs d'un entier p y compris lui-même et le nombre NB de ces
diviseurs.
2.écrire la procédure "affiche" permettant de vérifier si un nombre p
est sublime ou non. Cette procédure utilisera la fonction "parfait"
dont l'algorithme est mentionné ci-dessus.

28

Soit la suite (Pi)i impair définie par :

{ P1 =2 ¿ ¿ ¿ ¿
Ecrire un programme qui permet de calculer et d’afficher les termes de la
suite P jusqu’à ce que la différence entre deux termes consécutifs devienne
inférieure ou égale à 10-4.

26 Bac Scientifique Idoudi Khaled Enseignant :

 29
Ecrire une analyse et un algorithme intitulé "Annuaire" qui permet
de remplir 2 tableaux Tnom et Ttel en parallèle en respectant que à
chaque nom de Tnom correspond le numéro du téléphone de même indice
Exemple:
ABDELAZIZ RAMZI MOHAMMED KAIS WALID Tnom
29034598 90456032 75650222 27895312 92765324 Ttel
5 4 3 2 1 i
Questions:
1.écrire un module "Remplir_Contact" qui permet de remplir le tableau
Tnom en respectant qu’un nom est composé seulement de lettres majuscules
et le tableau Ttel en respectant qu'un numéro de téléphone est composé
exactement de 8 chiffres et commence obligatoirement par 7(tel fixe) ou
9(GSM Tuntel) ou 2(GSM Tunisiana) ou 5(GSM Orange)
2.écrire un module "Tri_nom" qui permet de trier les deux tableaux en
parallèle suivant l'ordre croissant des noms
3.écrire un module "Tri_tel" qui permet de trier les deux tableaux en
parallèle suivant l'ordre croissant des numéros
4.écrire le programme principal qui permet d'appeler les modules ci-
dessus et saisir un nom pour déterminer son numéro de téléphone s'il
existe ou saisir un numéro de téléphone pour connaître le nom de son
propriétaire en utilisant la recherche dichotomique.
NB : 5≤Nombre de contact≤50

30
Ecrire un programme qui permet de déterminer et d’afficher tous les
diviseurs suivis de tous les multiples d’un entier p donné, dans une partie
d’un tableau T de n entiers donnés. Cette partie est délimitée par deux
indices ind_inf et ind_sup. Avec (0<ind_inf<ind_sup ≤ n ≤ 15)
Exemple :

Pour n = 14, p = 8, ind_inf = 3 et ind_sup = 11, le programme affichera :

Les diviseurs de 8 sont : 4 2
Les multiples de 8 sont : 32 72 80 24 48

31
Soit le tableau T suivant :

Pour chaque élément de T on ne garde que sa première occurrence et on

remplace les autres par 0.

Pour regrouper les éléments restant au début du tableau T.

Ecrire un programme qui fait le traitement ci-dessus pour un tableau T de n

(2≤n≤20) entiers positifs non nuls et détermine et affiche le nombre
d’éléments différents de T.

27 Bac Scientifique Idoudi Khaled Enseignant :

32
Soit T, un tableau de n chaines de caractères représentants des
prénoms de n personnes, avec N ∈ [10..100[. Ecrire un programme
permettant de réaliser le traitement suivant:
1. Remplir le tableau T par N chaînes de caractères non vides,
2. Convertir tous les chaines en majuscules.
3. Trier dans l’ordre croissant le tableau T,
4. Supprimer tous les prénoms qui commencent par une lettre se
trouvant dans un intervalle de lettres [L1..L2], choisi par
l’utilisateur,
5. Vérifier, si un prénom saisit par l’utilisateur existe dans le
tableau ou non.
Exemple :
 Soit T avec le contenu initial suivant :
Siwar Mokhtar Ali Mohamed Warda Amir Wafa Rami Hanen T=

 Suite à l’opération de conversion le tableau sera comme suit :

SIWAR MOKTHAR ALI MOHAMED WARDA AMIR WAFA RAMI HANEN T=

 Suite à l’opération de tri le tableau T sera comme suit :

WARDA WAFA SIWAR RAMI MOHAMED MOKTHAR HANEN AMIR ALI T=

 Si l’intervalle des lettres choisi par l’utilisateur est

["M".."T"], tous les prénoms dont la 1 ère lettre se trouve dans cet
intervalle seront supprimés et le tableau T sera comme suit :
WARDA WAFA HANEN AMIR ALI T=

 Si l’utilisateur saisit le prénom « AMIR », le programme affiche

le message « existe ».

33
Soit T un tableau de N éléments (2<N<200) de type caractère. On désire
écrire un programme permettant de vérifier l’existence dans le tableau T
d’un certain nombre de mots saisis dans un tableau Tm de P éléments
(2<P<20).

Exemple :

Tm
T
Remarques :
1. Les caractères de la chaîne recherchée doivent être adjacents dans le
tableau T et non dispersés.
2. on remarque que les mots BAC, Canne et Sujet figurent dans le tableau
T.

28 Bac Scientifique Idoudi Khaled Enseignant :

34
L’algorithme suivant est celui d’une fonction permettant de calculer
la somme d’une partie d’éléments d’un tableau T de n entiers, délimité par
les indices p1 et p2.
0) Def FN somme (T : TAB ; p1,p2 : entier) : entier ;
1) [s  0] Pour i de p1 à p2 faire
Ss + T[i]
Fin Pour
2) somme s
3) Fin somme
En exploitant la fonction dont l’algorithme est ci-dessus, Ecrire un
programme qui permet de:
 Remplir automatiquement un tableau V de N entiers strictement
positifs et inférieurs à 100 (5 ≤ n ≤ 20).
 Afficher l’indice (ind) de l’élément du tableau dont l’écart entre la
somme (s1) des éléments qui le précédent et celle des éléments qui le
succèdent (s2) soit minimal
 Afficher les sommes s1 et s2 correspondantes
Exemple :
Pour le tableau V suivant :

Le programme affiche : S1 = 84, S2 = 80 et ind = 7

35
Soit T un tableau de N caractères alphabétique (2<N≤20)
Ecrire un programme Pascal permettant de crypter les données figurant
dans le tableau T comme suit :
1. Convertir chaque caractère en sa représentation en code ASCII.
2. Permuter les chiffres des unités avec ceux des dizaines.
3. Insérer le caractère correspondant à ce nouveau code ASCII dans un
tableau R. Puis afficher le tableau R obtenu.
Exemple :

"C" "A" "B" Si N=3 et T=

"L" "8" "B" Alors R=

Ord ("B") = 66, si on permute le chiffre de unité avec celui de dizaine

on obtient le code ASCII du caractère "B"
Ord ("A") = 65, si on permute, on obtient (56) le code ASCII du caractère
"8"
Ord ("C") = 67, si on permute, on obtient (76) le code ASCII du caractère
"L"

29 Bac Scientifique Idoudi Khaled Enseignant :

36
On se propose de dessiner un rectangle à l’aide d’un rectangle donné.
Le rectangle est formé de L lignes et C colonnes et il peut être plein ou
vide, selon le choix de l’utilisateur.
Ecrire un programme permettant de :
 Saisir les dimensions L et C du rectangle, sachant que L et C sont
deux entiers différents appartenant à l’intervalle [2..10]. L étant le
nombre de lignes et C le nombre de colonnes.
 Saisir le caractère de dessin parmi la liste (x,+,$,*)
 Saisir le choix du dessin qui peut être soit la lettre P (pour
plein) ou la lettre V (pour vide).
 Dessiner le rectangle selon les données fournies précédemment.
Exemples :
Si L=6, C=5, le caractère de dessin choisi Si L=4, C=7, le caractère de dessin choisi
est « $ » et le choix du dessin et V alors est « x » et le choix du dessin et P alors
le résultat affiché sera le suivant : le résultat affiché sera le suivant :
$$$$$ xxxxxxx
$ $ xxxxxxx
$ $ xxxxxxx
$ $ xxxxxxx
$ $
$$$$$

37
Soit un tableau T de N lettres minuscules (6<=N<=100), et soient D
et N deux entiers qui répondent aux conditions suivantes :
1. D est un entier diviseur de N strictement supérieur à 1.
2. M est un entier tel que N = M*D.
On se propose de trier les D éléments des M blocs disjoints qui
constituent le tableau T. Ecrire un programme permettant de :
 lire les deux entiers N et D qui répondent aux conditions 1. et 2.
 remplir le tableau T par N lettres minuscules,
 trier dans l'ordre croissant, les éléments de chaque bloc du
tableau T,
 afficher le tableau T après le tri.

30 Bac Scientifique Idoudi Khaled Enseignant :

38
Soit T un tableau de N chaînes de caractères non vides et dont la
taille maximale est 5 caractères. On se propose d'écrire un programme
Pascal permettant de réaliser le traitement suivant :
1. remplir le tableau T par N chaînes (2<=N<=30),
2. éliminer de chaque élément du tableau tous les caractères non
alphabétiques,
3. convertir toutes les chaines non vides obtenues en majuscule,
4. afficher toutes les chaines non vides palindromes
N.B: une chaîne est dite palindrome si elle se lit de la même façon de
gauche à droite et de droite à gauche. Exemples : AllA, RADAR, AA, Z
Exemple :
Si N=5 et les éléments de T sont :
h? 2009 Ra8d9ar 15aZ A54a T=
 Le tableau après l’étape 2 contiendra les chaînes suivantes
h Radar aZ Aa T=
 Le tableau après l’étape 3 contiendra les chaînes suivantes
H RADAR AZ AA T=
 Le programme affichera : AA RADAR H

39
On veut dessiner à l'aide du caractère "*", un triangle de hauteur H
(5< H<=10), comme indiqué dans l'exemple ci-dessous.
=

Exemple
Si H=6, le programme affichera le triangle suivant :
* * * * * * * * * * *
* * * * * * * * *
* * * * * * * H= 6 (6 lignes)
* * * * *
* * *
*
Ecrire un programme qui permet de saisir H, puis d'afficher le triangle.

40
Un CODEC est un logiciel compresseur décompresseur de fichiers. En
effet, les suites de bits composant un fichier comportent des similitudes
comme 10000111. Plutôt que de stocker la totalité de cet octet, on gagne de
la place en écrivant 14031 (qui se lit un quatre zéros trois un). Cet octet
(huit bits) retrouva ensuite son format original à la décompression.
Il s’agit alors de saisir une chaîne de huit chiffres formée uniquement 0
et 1 pour désigner un octet puis la compresser suivant le principe de
compression du CODEC et enfin l’afficher.
Exemple : Si octet = "10010111" Alors l’octet compressé est : "1201031"

31 Bac Scientifique Idoudi Khaled Enseignant :

 Solution

32 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 1

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var m,n) PROC Afficher(m,n) FN SomDiv(x)

 Analyse de programme principal :

 Algorithme de programme
Nom de programme : Parfait principal:
Résultat : PROC Afficher(n,m) 0) Début Parfait
PROC Saisie(n,m) 1) PROC Saisie(n,m)
Fin Parfait 2) PROC Afficher(n,m)
T.D.O Globaux 3) Fin Parfait
Objet T/N Rôle
N Entier Stocker la valeur de N
M Entier Stocker la valeur de M
Saisie Procédure Saisir les valeurs de N et M
Afficher Procédure Afficher tous les nombres parfaits compris entre n et m
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR X,Y :ENTIER)  Algorithme de la procédure Saisie

Résultat : x,y 0) DEF PROC SAISIE(VAR X,Y :ENTIER)
(x,y)=[] 1) Répéter
Répéter écrire("Donner la valeur de N : ")
x=donnée("Donner la valeur de N : ") lire(x)
y=donnée("Donner la valeur de M : ") écrire("Donner la valeur de M : ")
jusqu’à (X>Y)ET(Y>2) lire(y)
Fin Saisie jusqu’à (X>Y)ET(Y>2)
2) Fin Saisie

 Analyse de la procédure Afficher

DEF PROC AFFICHER(X,Y :ENTIER)
Résultat : Trait  Algorithme de la procédure
Trait=[]
Afficher
Pour i de x à y faire
Si(FN SomDiv(i)=i) alors 0) DEF PROC AFFICHER(X,Y :ENTIER)
Ecrire(i) 1) Pour i de x à y faire
Fin Si Si(FN SomDiv(i)=i) alors
Fin Pour Ecrire(i)
i : compteur Fin Si
Fin Afficher Fin Pour
2) Fin Afficher

33 Bac Scientifique Idoudi Khaled Enseignant :

 T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
SomDiv Fonction Calculer la somme des diviseurs d’un nombre
Analyse de la Fonction SomDiv
DEF FN SomDiv(X:ENTIER) : ENTIER
Résultat : SomDivS  Algorithme de la Fonction SomDiv
Trait=[]
0) DEF FN SomDiv(X:ENTIER) : ENTIER
S=[s0]Pour i de 1 à x div 2 faire
Si(x mod i = 0) alors 1) [s0]
SS+i 2) Pour i de 1 à x div 2 faire
Fin Si Si(x mod i = 0) alors
Fin Pour SS+i
i : compteur Fin Si
Fin SomDiv Fin Pour
3) SomDivS
T.D.O Locaux 4) Fin SomDiv
Objet T/N Rôle
i Entier Compteur
S Entier Calculer la somme des diviseurs de x
 Traduction Pascal
PROGRAM Parfait ; PROCEDURE Afficher(x,y :integer) ;
USES wincrt ; VAR
VAR i :integer ;
n,m :integer ; BEGIN
PROCEDURE Saisie(VAR x,y :integer) ; FOR i :=x to y do
BEGIN If(SomDiv(i) = i) then
REPEAT Writeln(i) ;
Write('Donner la valeur de N: '); END;
Readln(x) ; BEGIN
Write('Donner la valeur de M: '); Saisie(n,m) ;
Readln(y) ; Afficher(n,m) ;
UNTIL(x>y) and (y>2) ; END.
END;
FUNCTION SomDiv(x :integer) :integer ;
VAR
i,S :integer ;
BEGIN
S :=0 ;
FOR i :=1 to x div 2 do
If(x mod i = 0) then
S :=S+i ;
SomDiv := S ;
END ;

34 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 2

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC RemplirT1 PROC RemplirT2 PROC Afficher(N,T)

(N,var T) (N,T1,var T2)

FN SomCarre(X)

 Algorithme de programme
 Analyse de programme principal : principal:
0) Début Somme_Carre
Nom de programme : Somme_Carre
1) PROC Saisie(n)
Résultat : PROC Afficher(n,T2)
2) PROC RemplirT1(n,T1)
PROC RemplirT2(n,T1,T2)
3) PROC RemplirT2(n,T1,T2)
PROC RemplirT1(n,T1)
4) PROC Afficher(n,T2)
PROC Saisie(n)
5) Fin Somme_Carre
Fin Somme_Carre

T.D.N.T
Type
TAB= Tableau de taille 100 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier saisir la valeur de N
T1 TAB Remplir le tableau par N entier
Remplir le tableau par la somme des chiffres des
T2 TAB
éléments du tableau T1
Afficher Procédure Afficher un tableau de taille N
RemplirT1 Procédure Remplir un tableau de taille de taille N
Remplir le tableau T2 par la somme des chiffres des
RemplirT2 Procédure
éléments du tableau T1
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR X :ENTIER)

 Algorithme de la procédure Saisie
Résultat : x 0) DEF PROC SAISIE(VAR X :ENTIER)
x=[] 1) Répéter
Répéter écrire("Donner la valeur de N : ")
x=donnée("Donner la valeur de N : ") lire(x)
jusqu’à (X≥1)ET(X≤100) jusqu’à (X≥1)ET(X≤100)
Fin Saisie 2) Fin Saisie

35 Bac Scientifique Idoudi Khaled Enseignant :

 Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER,T :TAB)
Résultat : Trait
Trait=[]  Algorithme de la procédure
Pour i de 1 à N faire Afficher
Ecrire("T2[",i, "]=",T[i]) 0) DEF PROC AFFICHER(N :ENTIER,T :TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur Ecrire("T2[",i, "]=",T[i])
Fin Afficher 2) Fin Pour
T.D.O Locaux 3) Fin Afficher
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure RemplirT1
DEF PROC REMPLIRT1(N :ENTIER,VAR T :TAB)
Résultat : Trait
Trait=[]
 Algorithme de la procédure RemplirT1
Pour i de 1 à N faire 0) DEF PROC REMPLIRT1(N :ENTIER,VAR T:TAB)
Répéter 1) Pour i de 1 à N faire
T[i]=donnée("T1[",i, "]=") Répéter
jusqu’à (T[i]≤999)ET(T[i]≥100) écrire("T1[",i, "]=")
Fin Pour lire(T[i])
i : compteur jusqu’à (T[i]≤999)ET(T[i]≥100)
Fin RemplirT1 Fin Pour
T.D.O Locaux 2) Fin RemplirT1
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure RemplirT2
DEF PROC REMPLIRT2(N :ENTIER, T1 :TAB ,VAR T2 :TAB)
Résultat : T2
T2=[]  Algorithme de la procédure
Pour i de 1 à N faire RemplirT2
T2[i] FN SomCarre(T1[i]) 0) DEF PROC REMPLIRT2(N:ENTIER, T1 :TAB,
Fin Pour VAR T2 :TAB)
i : compteur 1) Pour i de 1 à N faire
Fin RemplirT2 T2[i] FN SomCarre(T1[i])
Fin Pour
2) Fin RemplirT2
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
SomCarre Fonction Calculer la somme des chiffres d’un entier

36 Bac Scientifique Idoudi Khaled Enseignant :

 Analyse de la Fonction SomCarre
DEF FN SomCarre(X:ENTIER) : ENTIER
Résultat : SomCarre S D(x mod 100 div) 10
Scarré(c)+ carré(d)+ carré(u) Ux mod 10
Cx div 100 Fin SomCarre

T.D.O Locaux  Algorithme de la Fonction

Objet T/N Rôle SomCarre
C,D,U Entier Déterminer 0) DEF FN SomCarre(X:ENTIER) : ENTIER
1) Cx div 100
les chiffres
2) D(x mod 100 div) 10
de X 3) Ux mod 10
S Entier Calculer la 4) Scarré(c)+ carré(d)+ carré(u)
somme des 5) SomCarre S
chiffres de x 6) Fin SomCarre
 Traduction Pascal
PROGRAM Somme_Carre; C :=x div 100 ;
USES wincrt ; D :=(x mod 100) div 10 ;
TYPE U :=x mod 10 ;
TAB=Array[1..100] of integer ; S := sqr(c)+ sqr(d)+ sqr(u) ;
VAR SomCarre:= S ;
n:integer ; END ;
T1,T2 :TAB ; PROCEDURE RemplirT2(n:integer ;T1 :TAB ;
PROCEDURE Saisie(VAR x :integer) ; VAR T2 :TAB) ;
BEGIN VAR
repeat i :integer ;
Write('Donner la valeur de N: '); BEGIN
Readln(x) ; FOR i :=1 to n do
until(X>=1)and(X<=100); T2[i]:= SomCarre(T1[i]) ;
END; END;
PROCEDURE RemplirT1(n:integer ;VAR
T :TAB) ; PROCEDURE Afficher(n:integer ;T :TAB) ;
VAR VAR
i :integer ; i :integer ;
BEGIN BEGIN
FOR i :=1 to n do FOR i :=1 to n do
REPEAT Writeln('T2[',i, ']= ',T[i]) ;
Write('T2[',i, ']= ') ; END;
Readln(T[i]) ; BEGIN
UNTIL (T[i]≥100) and (T[i]≤999); Saisie(n) ;
END; RemplirT1(n,T1) ;
FUNCTION SomCarre(x :integer):integer; RemplirT2(n,T1,T2) ;
VAR Afficher(n,T2) ;
S,c,d,u :integer ; END.
BEGIN

37 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 3

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC Afficher(N)

FN Impair(N) FN Palindrome(N)

 Analyse de programme principal :  Algorithme de programme

principal:
Nom de programme : Entier_palindrome
0) Début Entier_palindrome
Résultat : PROC Afficher(n)
1) PROC Saisie(n)
PROC Saisie(n)
2) PROC Afficher(n)
Fin Entier_palindrome
3) Fin Entier_palindrome
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la valeur de N
Saisie Procédure Saisir les valeurs de N
Afficher Procédure Afficher les n premiers nombres impairs et palindromes.
 Analyse de la procédure Saisie

Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x 0) DEF PROC SAISIE(VAR X :ENTIER)
x=[] 1) Répéter
Répéter écrire("Donner la valeur de N :
x=donnée("Donner la valeur de N : ") ")
jusqu’à (X≥5)ET(X≤20) lire(x)
Fin Saisie jusqu’à (X≥5)ET(X≤20)
 Analyse de la procédure Afficher
2) Fin Saisie
DEF PROC AFFICHER(N:ENTIER)  Algorithme de la procédure
Résultat : Trait Afficher
Trait=[][i1,x0]Répéter 0) DEF PROC AFFICHER(N:ENTIER)
Si(FN Impair(i))et(FN Palindrome(i))
1) [i1,x0]Répéter
alors
Si(FN Impair(i))et(FN Palindrome(i))
Ecrire(i)
alors
xx+1
Ecrire(i)
Fin Si
xx+1
ii+1
Fin Si
jusqu’à (x=N)
ii+1
Fin Afficher
jusqu’à (x=N)
T.D.O Locaux
2) Fin Afficher

38 Bac Scientifique Idoudi Khaled Enseignant :

 Objet T/N Rôle
i,x Entier Compteur
Impair Fonction Vérifier la parité d’un entier
palindrome Fonction Vérifier si un entier est palindrome ou non ?
 Analyse de la Fonction Impair
DEF FN Impair(X:ENTIER) : BOOLEEN
Résultat : Impair  x mod 2 = 0
Fin Impair  Algorithme de la Fonction Impair
0) DEF FN Impair(X:ENTIER) : BOOLEEN
Comparer le reste de la division de x par 2 1) Impair  x mod 2 ≠ 0
avec 0 : le résultat obtenu sera vrai ou faux 2) Fin Impair

 Analyse de la Fonction Palindrome

DEF FN Palindrome(X:ENTIER) : BOOLEEN
Résultat : Palindrome  ch = ch1
Ch1=[ch1""]  Algorithme de la Fonction
Pour i de long(ch) à 1 (pas=-1) faire Palindrome
ch1ch1+ch[i] 0) DEF FN Palindrome(X:ENTIER):BOOLEEN
Fin pour
1) Convch(x,ch)
Convch(x,ch)
2) [ch1""]
i:compteur
3) Pour i de long(ch) à 1 (pas=-
Fin Palindrome
1)faire
ch1ch1+ch[i]
T.D.O Locaux
Fin pour
Objet T/N Rôle 4) Palindrome  ch = ch1
i Entier Compteur 5) Fin Palindrome
Ch, Ch1 Chaine de Chaines
caractère auxiliaires
 Traduction Pascal
PROGRAM Entier_palindrome; BEGIN
USES wincrt ; Str(x,ch) ;ch1 :='' ;
VAR For i :=length(ch) downto 1 do
n :integer ; Ch1 := Ch1+ch[i] ;
PROCEDURE Saisie(VAR x :integer) ; Palindrome:= ch=ch1 ;
BEGIN END ;
repeat BEGIN
Write('Donner la valeur de N: '); X:=0 ; i:=1 ;
Readln(x) ; Repeat
until(x>=5)and(x<=20); If(Impair(i)) and (Palindrome(i)) then
END; begin
PROCEDURE Afficher(n :integer) ; Writeln(i) ; x:=x+1 ;
VAR end ;
x,i :integer ; i :=i+1 ;
FUNCTION Impair(x :integer) :boolean ; Until(x=n) ;
BEGIN END ;

39 Bac Scientifique Idoudi Khaled Enseignant :

 Impair := x mod 2 <> 0 ;
END ; BEGIN
FUNCTION Palindrome(x:integer): Saisie(n) ;
boolean; Afficher(n) ;
VAR END.
Ch,ch1 :string ;
i :integer ;

Exercice 4
 Décomposition modulaire du problème

Programme Principal

PROC Remplir(var N,var T) PROC Afficher(N,T)

FN Fact(N)

 Analyse de programme principal :  Algorithme de programme

principal:
Nom de programme : Som_Fact
0) Début Som_Fact
Résultat : PROC Afficher(n,T)
1) PROC Remplir (n,T)
PROC Remplir(n,T)
2) PROC Afficher(n,T)
Fin Som_Fact
3) Fin Som_Fact

T.D.N.T
Type
TAB= Tableau de taille 40 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la taille de tableau
T TAB Remplir le tableau par N entier
Afficher Procédure Afficher un tableau de taille N
Remplir le tableau par la somme des factorielles des
Remplir Procédure
chiffres d’un entier de 10 à 50.

 Analyse de la procédure Afficher

DEF PROC AFFICHER(N :ENTIER,T :TAB)
Résultat : Trait
 Algorithme de la procédure Afficher
40 Bac Scientifique 0) DEF PROC AFFICHER(N
Idoudi:ENTIER,T :TAB) :
Khaled Enseignant
1) Pour i de 1 à N faire
Pour j de 1 à i faire
Ecrire(T[i])
Trait=[]
Pour i de 1 à N faire
Pour j de 1 à i faire
Ecrire(T[i])
Fin Pour
Fin Pour
i,j : compteur
Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i,j Entier Compteur
 Analyse de la procédure Remplir
DEF PROC REMPLIR(VAR N :ENTIER, VAR T :TAB)
Résultat : T
T =[]  Algorithme de la procédure Remplir
Pour i de 10 à 50 faire 0) DEF PROC REMPLIR(VAR N:ENTIER,VAR
T[i-9] FN Fact(i div 10)+ T:TAB)
FN Fact(i mod 10) 1) N50-10+1
Fin Pour 2) Pour i de 10 à 50 faire
N 50 -10+1 T[i-9] FN Fact(i div 10)+
i : compteur FN Fact(i mod 10)
Fin Remplir Fin Pour
3) Fin Remplir
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Fact Fonction Calculer la factorielle d’un entier
 Analyse de la Fonction Fact
DEF FN Fact(X:ENTIER) : ENTIER  Algorithme de la Fonction Fact
Résultat : Fact  f 0) DEF FN Fact(X:ENTIER) : ENTIER
F=[f1]Pour i de 2 à x faire
1) [f1]
Ff*i
2) Pour i de 2 à x faire
Fin pour
ff*i
i:compteur
Fin pour
Fin Fact
3) Fact  f
4) Fin Fact
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
f Entier long Calculer la factorielle de x
 Traduction Pascal
PROGRAM Som_Fact; BEGIN
USES wincrt ; N :=50-10+1 ;

41 Bac Scientifique Idoudi Khaled Enseignant :

TYPE FOR i :=10 to 50 do
TAB=Array[1..50] of integer ; T[i-9]:=Fact(i div 10)+Fact(i mod 10);
VAR END;
n:integer ; PROCEDURE Afficher(n:integer ;T :TAB) ;
T :TAB ; VAR
PROCEDURE Remplir(VAR n:integer ;VAR i :integer ;
T :TAB) ; BEGIN
VAR FOR i :=1 to n do
i :integer ; Writeln('T[',i, ']= ',T[i]) ;
FUNCTION Fact(x :integer):integer; END;
VAR BEGIN
f,i :integer ; Remplir(n,T) ;
BEGIN Afficher(n,T) ;
f :=1 ; END.
for i :=2 to x do
f :=f*i ;
Fact :=f ;
END;

Exercice 5

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC Remplir( N,var T) PROC Afficher(N,T)

FN Max(N,T)

 Analyse de programme principal :  Algorithme de programme

principal:
Nom de programme : Chaine_longue
0) Début Chaine_longue
Résultat : PROC Afficher(n,T)
1) PROC Saisie(n)
PROC Remplir(n,T)
2) PROC Remplir(n,T)
PROC Saisie(n)
3) PROC Afficher(n,T)
Fin Chaine_longue
4) Fin Chaine_longue

T.D.N.T
Type
TAB= Tableau de taille 20 et de type chaine de caractère

42 Bac Scientifique Idoudi Khaled Enseignant :

 T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
T TAB Remplir le tableau par N chaines de caractère
Afficher Procédure Afficher les chaines ayant la longueur maximale
Remplir Procédure Remplir le tableau par n chaines de caractère.
Saisie Procédure Saisir la taille du tableau
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x
0) DEF PROC SAISIE(VAR X :ENTIER)
x=[]Répéter
x=donnée("Donner la valeur de N : ") 1) Répéter
jusqu’à (x>4)ET(x<20) écrire("Donner la valeur de N: ")
Fin Saisie lire(x)
jusqu’à (x>4)ET(x<20)
2) Fin Saisie

Analyse de la procédure Remplir

DEF PROC REMPLIR(N :ENTIER,VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
T[i]=donnée("T[",i, "]=") 0) DEF PROC REMPLIR(N :ENTIER,VAR T:TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur écrire("T[",i, "]=")
Fin Remplir lire(T[i])
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER,T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à N faire Afficher
si long(T[i])=m alors 0) DEF PROC AFFICHER(N :ENTIER,T :TAB)
Ecrire(T[i]) 1) mFN Max(n,T)
Fin Si 2) Ecrire("la longueur de la chaîne la
Fin Pour plus longue : ",m)
Ecrire("la longueur de la chaîne la 3) Pour i de 1 à N faire
plus longue : ",m) si long(T[i])=m alors
mFN Max(n,T) Ecrire(T[i])
i : compteur Fin Si
Fin Afficher Fin Pour
T.D.O Locaux 4) Fin Afficher
Objet T/N Rôle
i Entier Compteur
m Entier Stocker la longueur maximale des chaines

43 Bac Scientifique Idoudi Khaled Enseignant :

 Max Fonction Déterminer la longueur maximale des chaines
 Analyse de la Fonction Max
DEF FN Max(X:ENTIER, T :TAB) : ENTIER  Algorithme de la Fonction Max
Résultat : Max  m 0) DEF FN Max(X:ENTIER, T:TAB) :
m=[mlong(T[1])]
ENTIER
Pour i de 1 à x faire
si(long(T[i])>m) alors 1) [mlong(T[1])]
mlong(T[i]) 2) Pour i de 1 à x faire
Fin Si si(long(T[i])>m) alors
Fin pour mlong(T[i])
i:compteur Fin Si
Fin Max Fin pour
T.D.O Locaux 3) Max  m
4) Fin Max
Objet T/N Rôle
i Entier Compteur
m Entier Déterminer la longueur maximale des chaines
 Traduction Pascal
PROGRAM Chaine_longue; PROCEDURE Afficher(n:integer ;T :TAB) ;
USES wincrt ; VAR
TYPE m,i :integer ;
TAB=Array[1..20] of string[30] ; FUNCTION Max(x:integer;T:TAB):integer;
VAR VAR
n:integer ; m,i :integer ;
T :TAB ; BEGIN
PROCEDURE Saisie(VAR x :integer) ; m :=length(T[1]) ;
BEGIN FOR i :=1 to n do
repeat if(length (T[i])>m) then
Write('Donner la valeur de N: '); m :=length(T[i]) ;
Readln(x) ; Max :=m ;
until(x>4)and(x<20); END;
END; BEGIN
PROCEDURE Remplir(n:integer;VAR T:TAB); m :=Max(n,T) ;
VAR i :integer ; writeln(' la longueur de la chaîne la
BEGIN plus longue : ',m) ;
FOR i :=1 to n do FOR i :=1 to n do
begin if length (T[i])=m then
Write('T[',i, ']= ') ; Writeln(T[i]) ;
Readln(T[i]) ; END;
end; BEGIN Exercice 6
END; Saisie(n);Remplir(n,T);Afficher(n,T);
END.

44 Bac Scientifique Idoudi Khaled Enseignant :

  Décomposition modulaire du problème

Programme Principal

PROC Remplir(var N,var T) PROC Afficher(N,T)

FN divisible(N)

 Analyse de programme principal :  Algorithme de programme

principal:
Nom de programme : Div_Dizaine
0) Début Div_Dizaine
Résultat : PROC Afficher(n,T)
1) PROC Remplir (n,T)
PROC Remplir(n,T)
2) PROC Afficher(n,T)
Fin Div_Dizaine
3) Fin Div_Dizaine
T.D.N.T
Type
TAB= Tableau de taille 90 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la taille de tableau
T TAB Remplir le tableau par N entier
Afficher Procédure Afficher un tableau de taille N
Remplir les entiers de deux chiffres divisibles par
Remplir Procédure
leurs chiffres de dizaine
 Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER,T :TAB)
Résultat : Trait
 Algorithme de la procédure Afficher
Trait=[]Pour i de 1 à N faire 0) DEF PROC AFFICHER(N :ENTIER,T :TAB)
Si i mod 2 =0 alors 1) Pour i de 1 à N faire
Ecrire(T[i]) Si i mod 2 =0 alors
Fin Si Ecrire(T[i])
Fin Pour Fin Si
Pour i de 1 à N faire Fin Pour
Si i mod 2 ≠ 0 alors 2) Pour i de 1 à N faire
Ecrire(T[i]) Si i mod 2 ≠ 0 alors
Fin Si Ecrire(T[i])
Fin Pour Fin Si
i,j : compteur Fin Pour
Fin Afficher 3) Fin Afficher
T.D.O Locaux
Objet T/N Rôle

45 Bac Scientifique Idoudi Khaled Enseignant :

 i,j Entier Compteur
 Analyse de la procédure Remplir
DEF PROC REMPLIR(VAR N :ENTIER, VAR T :TAB)
Résultat : T
T=[n0]  Algorithme de la procédure Remplir
Pour i de 10 à 99 faire 0) DEF PROC REMPLIR(VAR N:ENTIER,VAR T:TAB)
Si FN divisible(i) alors 1) [N0]Pour i de 10 à 99 faire
nn+1 Si FN divisible (i) alors
T[n] i nn+1
Fin Si T[n] i
Fin Pour Fin Si
i : compteur Fin Pour
Fin Remplir 2) Fin Remplir
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
divisible Fonction Tester si un entier est divisible par son chiffre
de dizaine
 Analyse de la Fonction divisible
DEF FN Divisible(X:ENTIER) : BOOLEEN
Résultat : divisible  (x mod (x div 10))= 0
Fin divisible
 Algorithme de la Fonction divisible
0) DEF FN Divisible(X:ENTIER) : BOOLEEN
1) divisible  (x mod (x div 10))= 0
2) Fin divisible
 Traduction Pascal
PROCEDURE Remplir(VAR n:integer;VAR PROGRAM Div_Dizaine;
T:TAB); USES wincrt ;
VAR i :integer ; TYPE
FUNCTION Divisible(x:integer):Boolean; TAB=Array[1..90] of integer ;
BEGIN VAR
Divisible:=(x mod (x div 10))= 0; n:integer ;
END; T :TAB ;
BEGIN PROCEDURE Afficher(n:integer ;T :TAB);
N :=0 ; VAR i :integer ;
FOR i :=10 to 99 do BEGIN
if(divisible(i)) then FOR i :=1 to n do
begin if(i mod 2 =0) then
n :=n+1 ; Write(T[i]) ;
T[n] :=i ; FOR i :=1 to n do
end ; if(i mod 2 ≠0) then
END; Write(T[i]) ;
BEGIN END;
Remplir(n,T) ;

46 Bac Scientifique Idoudi Khaled Enseignant :

 Afficher(n,T) ;
END.

Exercice 7

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC Remplir( N,var T) FN PrdSc(N,T1,T2)

 Analyse de programme principal :

 Algorithme de programme
Nom de programme : Produit_scalire principal:
Résultat: Ecrire("Le produit scalaire est : ", 0) Début Produit_scalire
FN PrdSc(n,A,B)) 1) PROC Saisie(n)
PROC Remplir(n,A) 2) PROC Remplir(n,A)
PROC Remplir(n,B) 3) PROC Remplir(n,B)
PROC Saisie(n) 4) Ecrire("Le produit
Fin Produit_scalire scalaire est : ", FN
PrdSc(n,A,B))
5) Fin Produit_scalire
T.D.N.T
Type
TAB= Tableau de taille 50 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
A,B TAB Remplir les tableaux par N entiers positifs
Remplir Procédure Remplir un tableau par N entiers positifs.
Saisie Procédure Saisir la taille du tableau
PrdSc Fonction Calculer le produit scalaire de deux tableaux

 Analyse de la procédure Saisie

 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
0) DEF PROC SAISIE(VAR X :ENTIER)
47 Bac Scientifique 1) Répéter Idoudi Khaled Enseignant :
écrire("Donner la valeur de N: ")
lire(x)
jusqu’à (x≥5)ET(x≤50)
Résultat : x
x=[]Répéter
x=donnée("Donner la valeur de N : ")
jusqu’à (x≥5)ET(x≤50)
Fin Saisie

Analyse de la procédure Remplir

DEF PROC REMPLIR(N :ENTIER,VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR(N :ENTIER,VAR T:TAB)
T[i]=donnée("T[",i, "]=")
1) Pour i de 1 à N faire
Jusqu’à (T[i]≥0)
Répéter
Fin Pour
écrire("T[",i, "]=")
i : compteur
lire(T[i])
Fin Remplir
Jusqu’à (T[i]≥0)
T.D.O Locaux
Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur

Analyse de la Fonction PrdSc

DEF FN PrdSc(X:ENTIER, T1,T2 :TAB): ENTIER LONG
Résultat : PrdSc  s  Algorithme de la Fonction PrdSc
S=[s0]
Pour i de 1 à x faire 0) DEF FN PrdSc (X:ENTIER,T1,T2:TAB): ENTIER
Ss+T1[i]*T2[i] LONG
Fin pour 1) [s0]
i:compteur 2) Pour i de 1 à x faire
Fin PrdSc Ss+T1[i]*T2[i]
Fin pour
3) PrdSc  s
T.D.O Locaux 4) Fin PrdSc
Objet T/N Rôle
i Entier Compteur
s Entier long Calculer le produit scalaire de deux vecteurs

Traduction Pascal
PROGRAM Produit_scalire; FUNCTION PrdSc(x:integer;T1,T2:TAB):
USES wincrt ; longint;
TYPE TAB=Array[1..20] of integer ; VAR s : longint ;
VAR i :integer ;
n:integer ; BEGIN
A,B :TAB ; S :=0 ;

48 Bac Scientifique Idoudi Khaled Enseignant :

PROCEDURE Saisie(VAR x :integer) ; FOR i :=1 to n do
BEGIN S :=s+ T1[i]*T2[i] ;
repeat PrdSc:=s ;
Write('Donner la valeur de N: '); END;
Readln(x) ; BEGIN
until(x>=5)and(x<=50); Saisie(n) ;
END; Remplir(n,A);
PROCEDURE Remplir(n:integer;VAR T:TAB); Remplir(n,B);
VAR i :integer ; Write(' Le produit scalaire est : ',
BEGIN PrdSc(n,A,B)) ;
FOR i :=1 to n do END.
repeat
Write('valeur ',i,'=') ;
Readln(T[i]) ;
Until(T[i]≥0) ;
END;

Exercice 8

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC Remplir( N,var T) FN MoyOlympique(N,T)

FN Max(N,T) FN Min(N,T)

 Analyse de programme principal :  Algorithme de programme

principal:
Nom de programme : Moyenne_Olympique
0) Début Moyenne_Olympique
Résultat: Ecrire("La moyenne olympique est : ",
1) PROC Saisie(n)
FN MoyOlympique(n,T))
2) PROC Remplir(n,T)
PROC Remplir(n,T)
3) Ecrire("La moyenne
PROC Saisie(n)
olympique est : ", FN
Fin Moyenne_Olympique
T.D.N.T MoyOlympique(n,T))
Type 4) Fin Moyenne_Olympique
TAB= Tableau de taille 20 et de type réel
T.D.O Globaux
Objet T/N Rôle

49 Bac Scientifique Idoudi Khaled Enseignant :

 N Entier stocker la taille du tableau
T TAB Remplir les tableaux par N réels
Remplir Procédure Remplir un tableau par N réels
Saisie Procédure Saisir la taille du tableau
MoyOlympique Fonction Calculer la moyenne olympique
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x
0) DEF PROC SAISIE(VAR X :ENTIER)
x=[]Répéter
x=donnée("Donner la valeur de N : ") 1) Répéter
jusqu’à (x≥5)ET(x≤20) écrire("Donner la valeur de N: ")
Fin Saisie lire(x)
jusqu’à (x≥5)ET(x≤20)
2) Fin Saisie

 Analyse de la procédure Remplir

DEF PROC REMPLIR(N :ENTIER,VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
T[i]=donnée("T[",i, "]=")
0) DEF PROC REMPLIR(N :ENTIER,VAR T:TAB)
Fin Pour
i : compteur 1) Pour i de 1 à N faire
Fin Remplir écrire("T[",i, "]=")
T.D.O Locaux lire(T[i])
Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur
 Analyse de la Fonction MoyOlympique
DEF FN Moyolympique(N:ENTIER, T:TAB): RÉEL
Résultat : MoyOlympique  m
m(s-FN min(n,T)- FN max(n,T))/(n-2)  Algorithme de la Fonction
S=[s0] MoyOlympique
Pour i de 1 à n faire 0) DEF FN Moyolympique(N:ENTIER, T:TAB):
Ss+T[i] RÉEL
Fin pour 1) [s0]
i:compteur 2) Pour i de 1 à n faire
Fin MoyOlympique Ss+T[i]
Fin pour
3) m(s-FN min(n,T)-FN max(n,T))/(n-2)
T.D.O Locaux 4) MoyOlympique  m
Objet T/N Rôle
5) Fin MoyOlympique
i Entier Compteur
s Réel Calculer la somme des éléments d’un vecteur
m Réel Calculer la moyenne olympique

50 Bac Scientifique Idoudi Khaled Enseignant :

  Analyse de la Fonction Max
DEF FN Max(N:ENTIER, T :TAB) : REEL  Algorithme de la Fonction Max
Résultat : Max  m
0) DEF FN Max(N:ENTIER, T:TAB) : REEL
m=[mT[1]]
Pour i de 1 à n faire 1) [mT[1]]
si(T[i]>m) alors 2) Pour i de 1 à n faire
mT[i] si(T[i]>m) alors
Fin Si mT[i]
Fin pour Fin Si
i:compteur Fin pour
Fin Max 3) Max  m
T.D.O Locaux 4) Fin Max
Objet T/N Rôle
i Entier Compteur
m Réel Déterminer la valeur maximale d’une liste des valeurs
 Analyse de la Fonction Min
DEF FN Min(N:ENTIER, T :TAB) : REEL  Algorithme de la Fonction Min
Résultat : Min  m
0) DEF FN Min(N:ENTIER, T:TAB) : REEL
m=[mT[1]]
Pour i de 1 à n faire 1) [mT[1]]
si(T[i]<m) alors 2) Pour i de 1 à n faire
mT[i] si(T[i]<m) alors
Fin Si mT[i]
Fin pour Fin Si
i:compteur Fin pour
Fin Min 3) Min  m
T.D.O Locaux 4) Fin Min
Objet T/N Rôle
i Entier Compteur
m Réel Déterminer la valeur minimale d’une liste des valeurs

 Traduction Pascal
PROGRAM Moyenne_Olympique; PROCEDURE Saisie(VAR x :integer) ;
USES wincrt ; BEGIN
TYPE TAB=Array[1..20] of real ; repeat
VAR Write('Donner la valeur de N: ');
n:integer ; Readln(x) ;

51 Bac Scientifique Idoudi Khaled Enseignant :

 T :TAB ; until(x>=5)and(x<=20);
FUNCTION MoyOlympique END;
(n:integer;T:TAB) :real; PROCEDURE Remplir(n:integer;VAR
VAR i :integer ; T:TAB);
S,m:real ; VAR i :integer ;
FUNCTION Max(n:integer;T:TAB):real; BEGIN
VAR FOR i :=1 to n do
i :integer ; begin
m :real ;
Write('T[',i, ']= ') ;
BEGIN
m := T[1] ; Readln(T[i]) ;
FOR i :=1 to n do end ;
if(T[i]>m) then END;
m := T[i] ;
Max :=m ; BEGIN
END; Saisie(n) ;
FUNCTION Min(n:integer;T:TAB):real;
VAR Remplir(n,T);
i :integer ; Write('La moyenne olympique est : ',
m :real ; MoyOlympique(n,T):2:3);
BEGIN END.
m := T[1] ;
FOR i :=1 to n do
if(T[i]<m) then
m := T[i] ;
Min :=m ;
END;
BEGIN
S :=0 ;
FOR i :=1 to n do
S :=s+ T[i];
m :=(s-Min(n,T)-Max(n,T))/(n-2) ; Exercice 9
MoyOlympique:=m ;
END;
 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC Remplir( N,var T) PROC TabARN( N,D,var R) PROC Afficher( N,T)

FN ADNtoARN(c)

 Analyse de programme principal :

 Algorithme de programme
Nom de programme : ADN_ARN principal:
Résultat: PROC Afficher(N,R) 0) Début ADN_ARN
1) PROC Saisie(n)
52 Bac Scientifique 2) PROCIdoudi Khaled Enseignant :
Remplir(n,D)
3) PROC TabARN(n,D,R)
4) PROC Afficher(N,R)
5) Fin ADN_ARN
PROC TabARN(n,D,R)
PROC Remplir(n,D)
PROC Saisie(n)
Fin ADN_ARN

T.D.N.T
Type
TAB= Tableau de taille 30 et de type caractère
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
D TAB Remplir le tableau par le code ADN
R TAB Remplir le tableau par le code ARN du tableau D
Remplir Procédure Remplir un tableau par un code ADN.
Saisie Procédure Saisir la taille du tableau
TabARN Fonction Convertir un code ADN en code ARN
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x
0) DEF PROC SAISIE(VAR X :ENTIER)
x=[]Répéter
x=donnée("Donner la valeur de N : ") 1) Répéter
jusqu’à (x≥5)ET(x≤30) écrire("Donner la valeur de N: ")
Fin Saisie lire(x)
jusqu’à (x≥5)ET(x≤30)
2) Fin Saisie

Analyse de la procédure Remplir

DEF PROC REMPLIR(N :ENTIER,VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR(N :ENTIER,VAR T:TAB)
T[i]=donnée 1) Pour i de 1 à N faire
Jusqu’à Répéter
Majus(T[i])dans["A","T","C","G"] lire(T[i])
Fin Pour Jusqu’à
i : compteur Majus(T[i]) dans["A","T","C","G"]
Fin Remplir Fin Pour
T.D.O Locaux 2) Fin Remplir
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER,T :TAB)
 Algorithme de la procédure
53 Bac Scientifique Idoudi Khaled Enseignant :
Afficher
0) DEF PROC AFFICHER(N :ENTIER,T :TAB)
1) Ecrire("Le code ARN est :")
Résultat : Trait
Trait=[]Pour i de 1 à N faire
Ecrire(T[i])
Fin Pour
Ecrire("Le code ARN est :")
i : compteur
Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure TabARN
DEF PROC TabARN(N :ENTIER,D:TAB,VAR R:TAB)
Résultat : R
R=[]Pour i de 1 à N faire  Algorithme de la procédure TabARN
R[i]FN ADNtoARN(D[i])
0) DEF PROC TabARN(N:ENTIER,D:TAB,VAR
Fin Pour
i : compteur R:TAB)
Fin TabARN 1) Pour i de 1 à N faire
R[i]FN ADNtoARN(D[i])
Fin Pour
2) Fin TabARN
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
ADNtoARN Fonction Convertir un caractère de code ADN en caractère du code
ARN

Analyse de la Fonction ADNtoARN

DEF FN ADNtoARN(C : CARACTERE): CARACTERE
Résultat : ADNtoARN  c
Selon majus(c) faire  Algorithme de la Fonction ADNtoARN
"A" : c  "U" 0) DEF FN ADNtoARN(C : CARACTERE): CARACTERE
"T" : c  "A" 1) Selon majus(c) faire
"C" : c  "G" "A" : c  "U"
"G" : c  "C" "T" : c  "A"
Fin selon "C" : c  "G"
Fin ADNtoARN "G" : c  "C"
Fin selon
2) ADNtoARN  c
3) Fin ADNtoARN
Traduction Pascal
PROGRAM ADN_ARN; PROCEDURE TabARN(n:integer;D :TAB;
USES wincrt ; VAR R:TAB);

54 Bac Scientifique Idoudi Khaled Enseignant :

TYPE TAB=Array[1..30] of char ; VAR i :integer ;
VAR FUNCTION ARNtoADN(c :char):char;
n:integer ; BEGIN
A,B :TAB ; Case UPCASE(c) of
PROCEDURE Saisie(VAR x :integer) ; 'A' : c := 'U' ;
'T' : c := 'A' ;
BEGIN
'C' : c := 'G' ;
repeat
'G' : c := 'C' ;
Write('Donner la valeur de N: '); End ;
Readln(x) ; ARNtoADN:=c ;
until(x>=5)and(x<=30); END;
END; BEGIN
PROCEDURE Remplir(n:integer;VAR T:TAB); FOR i :=1 to n do
VAR i :integer ; R[i] := ARNtoADN(D[i]) ;
BEGIN END;
Write('Le code ADN: ') ;
FOR i :=1 to n do BEGIN
repeat Saisie(n) ;
Read(T[i]) ; Remplir(n,D);
Until UPCASE(T[i])in ['A','T','C','G']; TabARN(n,D,R);
END; Afficher(n,R);
PROCEDURE Afficher(n:integer ;T :TAB); END.
VAR i :integer ;
BEGIN
Write('Le code ARN est :
') ;
FOR i :=1 to n do Exercice 10
Write(T[i]) ;
END;

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var ch) FN Nb_Gauche( ch)

FN Nb_Droite( ch)

 Analyse de programme principal :

 Algorithme de programme
Nom de programme : Extraire_Nombre principal:
Résultat: Ecrire("Nombre droite : ", 0) Début Extraire_Nombre
FN Nb_Droite(ch)," Nombre gauche : ", 1) PROC Saisie(ch)
FN Nb_Gauche(ch)) 2) Ecrire("Nombre droite : ",
PROC Saisie(ch) FN Nb_Droite(ch)," Nombre
Fin Extraire_Nombre gauche : ",FN Nb_Gauche(ch))
3) Fin Extraire_Nombre

55 Bac Scientifique Idoudi Khaled Enseignant :

 T.D.O Globaux
Objet T/N Rôle
ch Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
Extraire un nombre formé par les chiffres de
Nb_Droite Fonction
ch de droite à gauche
Extraire un nombre formé par les chiffres de
Nb_Gauche Fonction
ch de gauche à droite
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères) Saisie
Résultat : ch
0) DEF PROC SAISIE(VAR ch:chaine
ch=[]Répéter
de caractères)
ch=donnée("Donner une chaine : ")
1) Répéter
jusqu’à long(ch)≠0
Fin Saisie écrire("Donner une chaine ")
lire(ch)
jusqu’à long(ch)≠0
2) Fin Saisie

 Analyse de la procédure Nb_Droite

DEF PROC NB_Droite(CH:chaine de caractères) :ENTIER
Résultat : Nb_Droitenb
Si ch1="" alors nb0
Sinon valeur(ch1,nb,e)  Algorithme de la procédure Nb_Droite
Fin si 0) DEF PROC NB_Droite(CH:chaine de
Pour i de long(ch) à 1 (pas=-1)faire caractères) :ENTIER
Si(ch[i])dans['0'..'9'] alors 1) Pour i de long(ch) à 1 (pas=-1)faire
Ch1ch1+ch[i] Si(ch[i])dans['0'..'9'] alors
Fin si Ch1ch1+ch[i]
Fin Pour Fin si
i : compteur Fin Pour
Fin Nb_Droite 2) Si ch1="" alors nb0
Sinon valeur(ch1,nb,e)
Fin si
3) Nb_Droitenb
4) Fin Nb_Droite
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
e Entier Position d’erreur
nb Entier Convertir la chaine ch1 en nombre
Ch1 chaine Chaine auxiliaire
 Analyse de la procédure Nb_Gauche
DEF PROC NB_Gauche(CH:chaine de caractères) :ENTIER

56 Bac Scientifique Idoudi Khaled Enseignant :

Résultat : Nb_Gauche nb
Si ch1="" alors nb0  Algorithme de la procédure Nb_
Sinon valeur(ch1,nb,e) Gauche
Fin si 0) DEF PROC NB_Gauche(CH:chaine de
Pour i de 1 à long(ch) faire caractères) :ENTIER
Si(ch[i])dans['0'..'9'] alors 1) Pour i de 1 à long(ch) faire
Ch1ch1+ch[i] Si(ch[i])dans['0'..'9'] alors
Fin si Ch1ch1+ch[i]
Fin Pour Fin si
i : compteur Fin Pour
Fin Nb_Gauche 2) Si ch1="" alors nb0
Sinon valeur(ch1,nb,e)
Fin si
3) Nb_Gauchenb
 T.D.O Locaux 4) Fin Nb_Gauche
Objet T/N Rôle
i Entier Compteur
e Entier Position d’erreur
nb Entier Convertir la chaine ch1 en nombre
Ch1 chaine Chaine auxiliaire
 Traduction Pascal
PROGRAM Extraire_Nombre; FUNCTION Nb_Gauche(ch:string): longint;
USES wincrt ; VAR nb : longint ;
VAR Ch :string ; i,e :integer ;
PROCEDURE Saisie(VAR ch :string) ; Ch1 :string ;
BEGIN BEGIN
repeat FOR i :=1 to length(ch) do
Write('Donner une chaine: '); If ch[i] in ['0','9'] then
Readln(ch) ; Ch1 := Ch1+ Ch[i] ;
until length(ch)<>0 ; val(ch1,nb,e) ; Nb_Gauche:=nb ;
END; END;
FUNCTION Nb_Droite(ch :string):longint; BEGIN
VAR nb :longint Saisie(ch) ;
i,e :integer ; Write('Nombre droite : ',
Ch1 :string ; Nb_Droite(ch),' Nombre gauche : ',
BEGIN Nb_gauche(ch)) ;
FOR i :=length(ch) downto 1 do END.
If ch[i] in ['0','9'] then
Ch1 := Ch1+ Ch[i] ;
val(ch1,nb,e) ; Nb_Droite:=nb ;
END;

Exercice 11

57 Bac Scientifique Idoudi Khaled Enseignant :

  Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N) PROC Trier(N,var PROC
T) PROC Afficher(N,T)
Inserer(x,var N,var T)
Remplir( N,var T)

FN Min(p,N,T) PROC Permut(var x,y)

 Analyse de programme principal :

 Algorithme de programme
Nom de programme : Inserer_Nombre principal:
Résultat : PROC Afficher(n,T) 0) Début Inserer_Nombre
1) PROC Saisie(n)
PROC Inserer(x,n,T)
2) PROC Remplir(n,T)
PROC Trier(n,T)
3) PROC Trier(n,T)
PROC Remplir(n,T)
4) Ecrire("Donner l’entier à insérer")
PROC Saisie(n) 5) Lire(x)
X=donnée("Donner l’entier à insérer") 6) PROC Inserer(x,n,T)
Fin Inserer_Nombre 7) PROC Afficher(n,T)
T.D.N.T 8) Fin Inserer_Nombre
Type
TAB= Tableau de taille 30 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
T TAB Remplir le tableau par N entiers
x Entier Saisir un entier à insérer dans le tableau T
Afficher Procédure Afficher un tableau
Remplir Procédure Remplir le tableau par n entiers.
Saisie Procédure Saisir la taille du tableau
Trier Procédure Trier le tableau T dans l’ordre croissant
Insérer l’entier x dans le Tableau T en conservant
Insérer Procédure
l’ordre
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x 0) DEF PROC SAISIE(VAR X :ENTIER)
x=[]Répéter 1) Répéter
x=donnée("Donner la valeur de N : ") écrire("Donner la valeur de N: ")
jusqu’à (x≥5)ET(x≤30) lire(x)
Fin Saisie jusqu’à (x≥5)ET(x≤30)
2) Fin Saisie
58 Bac Scientifique Idoudi Khaled Enseignant :
 Analyse de la procédure Remplir
DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
T[i]=donnée("T[",i, "]=") 0) DEF PROC REMPLIR(N :ENTIER ;VAR T:TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur écrire("T[",i, "]=")
Fin Remplir lire(T[i])
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER ;T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à N faire Afficher
Ecrire("T[",i, "]=",T[i]) 0) DEF PROC AFFICHER(N:ENTIER ;T :TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur Ecrire("T[",i, "]=",T[i])
Fin Afficher Fin Pour
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure Trier
DEF PROC TRIER(N :ENTIER ;VAR T :TAB)
Résultat : T  Algorithme de la procédure Trier
T =[]Pour i de 1 à N-1 faire 0) DEF PROC TRIER(N :ENTIER ;VAR T:TAB)
posminFN Min(i,N,T) 1) Pour i de 1 à N faire
si posmin ≠ i alors posminFN Min(i,N,T)
PROC Permut(T[posmin],T[i]) si posmin ≠ i alors
Fin Si PROC Permut(T[posmin],T[i])
Fin Pour Fin Si
i : compteur Fin Pour
Fin Trier 2) Fin Trier
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Min Fonction Déterminer la position de minimum dans un tableau à
partir d’une position pos
Permut Procédure Permuter deux entiers dans un tableau
Analyse de la Fonction Min
DEF FN Min(pos,n:ENTIER;T:TAB):ENTIER  Algorithme de la Fonction Min
0) DEF FN Min(pos,n:ENTIER ;T:TAB):
59 Bac Scientifique ENTIER Idoudi Khaled Enseignant :
1) [posminpos]
Pour i de pos+1 à n faire
si(T[i]<T[posmin]) alors
Résultat : Min  posmin
posmin =[posminpos]
Pour i de pos+1 à n faire
si(T[i]<T[posmin]) alors
posmini
Fin Si
Fin pour
i:compteur
Fin Min

T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
posmin entier Déterminer la position de minimum dans un tableau à partir
d’une position pos
 Analyse de la procédure Permut
DEF PROC PERMUT(VAR X,Y :ENTIER)  Algorithme de la procédure Permut
Résultat : x,y
0) DEF PROC PERMUT(VAR X,Y :ENTIER)
auxx
xy 1) Auxx
yaux 2) Xy
Fin Permut 3) Yaux
T.D.O Locaux 4) Fin Permut
Objet T/N Rôle
aux Entier Variable auxiliaire
 Analyse de la procédure Insérer
DEF PROC INSERER(X:ENTIER ;VAR N :ENTIER ;VAR T :TAB)
Résultat : N,T
T[i+1]x  Algorithme de la procédure Insérer
NN+1 0) DEF PROC INSERER(X:ENTIER; VAR N:ENTIER;
[iN]Tant que (T[i]>x)et(i>1) faire
VAR T:TAB)
T[i+1]T[i]
ii-1 1) [iN]Tant que (T[i]>x)et(i>1) faire
Fin Tant que T[i+1]T[i]
Fin Trier ii-1
T.D.O Locaux Fin Tant que
2) T[i+1]x
Objet T/N Rôle
3) NN+1
i Entier Compteur 4) Fin Inserer
 Traduction Pascal
PROGRAM Inserer_Nombre; PROCEDURE Trier(n:integer ; VAR
USES wincrt ; T :TAB) ;
TYPE TAB=Array[1..20] of integer ; VAR posmin,i :integer ;
VAR FUNCTION Min(pos,n:integer;T:TAB):integer;
N,x:integer ; VAR posmin,i :integer ;
T :TAB ; BEGIN

60 Bac Scientifique Idoudi Khaled Enseignant :

PROCEDURE Saisie(VAR x :integer) ; posmin:=pos;
BEGIN for i := pos+1 to n do
repeat if(T[i]<T[posmin]) then
Write('Donner la valeur de N: '); posmin:=i;
Readln(x) ; Min := posmin;
END;
until(x>=5)and(x<=30);
PROCEDURE Permut(VAR x,y:integer);
END; VAR aux :integer ;
PROCEDURE Remplir(n:integer;VAR T:TAB); BEGIN
VAR i :integer ; aux :=x ;
BEGIN x :=y ;
for i :=1 to n do y :=aux ;
begin END;
Write('T[',i, ']= ') ; BEGIN
Readln(T[i]) ; for i :=1 to n do
end; begin
END; Posmin := Min(i,N,T) ;
PROCEDURE Afficher(n:integer ;T :TAB) ; if posmin <> i then
VAR i :integer ; Permut(T[posmin],T[i]) ;
BEGIN end;
write('T=') ; END;
for i :=1 to n do
Write(T[i],' ') ;
END;
PROCEDURE Inserer(x:integer; VAR BEGIN
n:integer ;VAR T:TAB); Saisie(n) ;
VAR i :integer ; Remplir(n,T);
BEGIN Trier(n,T) ;
i:=N ; Write('Donner l’entier à insérer: ');
while (T[i]>x)and(x>1)do Readln(x) ;
Begin Inserer(x,n,T) ;
T[i+1] :=T[i] ; Afficher(n,T) ;
i :=i-1 ; END.
end ;
T[i+1] :=x ;
N :=N+1 ;
END;

 Décomposition modulaire du problème Exercice 12

Programme Principal

PROC Afficher (ch)

PROC Saisie(var ch)

 Analyse de programme principal :  Algorithme de programme

Nom de programme : Sablier principal:
0) Début Sablier
61 Bac Scientifique 1) PROCIdoudi Khaled Enseignant :
Saisie(ch)
2) PROC Afficher(ch)
3) Fin Sablier
Résultat: PROC Afficher(ch)
PROC Saisie(ch)
Fin Sablier

T.D.O Globaux
Objet T/N Rôle
ch Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
Afficher Procédure Afficher une chaine sous forme d’un sablier
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères) Saisie
Résultat : ch 0) DEF PROC SAISIE(VAR ch:chaine
ch=[]Répéter de caractères)
ch=donnée("Donner une chaine : ") 1) Répéter
jusqu’à long(ch) mod 2 ≠0
écrire("Donner une chaine : ")
Fin Saisie
lire(ch)
jusqu’à long(ch) mod 2 ≠ 0
2) Fin Saisie
 Analyse de la procédure Afficher
DEF PROC AFFICHER(CH :chaine de caractères)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à long(ch) faire Afficher
Si i<=long(ch)div 2 alors
0) DEF PROC AFFICHER(CH: chaine de
n long(ch)-2*(i-1)
P i caractères)
Sinon 1) Pour i de 1 à long(ch) faire
n 2*i-long(ch) Si i<=long(ch)div 2 alors
P long(ch)-i +1 n  long(ch)-2*(i-1)
Fin Si Pi
nbp-1+n Sinon
Ecrire(sous-chaine(ch,p,n):nb) n  2*i-long(ch)
Fin Pour P long(ch)-i +1
i : compteur Fin Si
Fin Afficher nbp-1+n
Ecrire(sous-chaine(ch,p,n):nb)
T.D.O Locaux Fin Pour
2) Fin Afficher
Objet T/N Rôle
i Entier Compteur
n Entier Calculer le nombre de caractère à afficher
p Entier Calculer la position dont lequel on va commencer à
afficher la chaine ch
nb Entier Calculer le nombre position pour afficher la chaine ch
Traduction Pascal
PROGRAM Sablier ; PROCEDURE Saisie(VAR ch :string) ;

62 Bac Scientifique Idoudi Khaled Enseignant :

USES wincrt ; BEGIN
VAR Ch :string ; REPEAT
PROCEDURE Afficher(ch :string) ; Write('Donner une chaine: ');
VAR n,p,nb,i :integer ;
Readln(ch) ;
BEGIN
for i:=1 to length(ch) do UNTIL length(ch) mod 2 <> 0 ;
begin END;
if(i<=length(ch) div 2) then BEGIN
begin Saisie(ch) ;
n:= length(ch)-2*(i-1) ; Afficher(ch) ;
p:=i; END.
end
else
begin
n:=2*i-length(ch) ;
p:=length(ch)-i+1;
end;
nb:=p-1+n; writeln(copy(ch,p,n):nb) ; Exercice 13
end;
END ;
 Décomposition modulaire du problème

Programme Principal

 Analyse de programme
PROC Saisie(var ch)
FN SuppEspace:(ch)
principal  FN Renverser (ch) de
Algorithme programme
Nom de programme : Renverser_chaine principal:
Résultat: écrire("Chaine résultat: ",
0) Début Renverser_chaine
FN Renverser(ch))
1) PROC Saisie(ch)
ChFN SuppEspace(ch)
2) ChFN SuppEspace(ch)
PROC Saisie(ch)
3) écrire("Chaine résultat:
Fin Renverser_chaine
",FN Renverser(ch))
T.D.O Globaux 4) Fin Renverser_chaine
Objet T/N Rôle
ch Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
Supprimer les espaces inutiles dans une
SuppEspace Fonction
chaine
Renverser Fonction Renversée les mots d’une phrase
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères)
Saisie
Résultat : ch
0) DEF PROC SAISIE(VAR ch:chaine
de caractères)
63 Bac Scientifique 1) Répéter Idoudi Khaled Enseignant :
écrire("Donner une chaine : ")
lire(ch)
jusqu’à Majus(ch[1]) dans
ch=[]Répéter
ch=donnée("Donner une chaine : ")
jusqu’à Majus(ch[1]) dans ["A".."Z"]
Fin Saisie

 Analyse de la Fonction Renverser

DEF FN Renverser(CH:chaine de caractères): chaine de caractères
Résultat : Renverser  ch1
Ch1 =[p1]
Pour i de 1 à long(ch) faire
si(ch[i]=" ") alors
mot" "+sous-chaine(ch,p,i-p)  Algorithme de la Fonction
pi+1
Renverser
Fin Si
si(i=long(ch)) alors 0) DEF FN Renverser(ch :chaine de
motsous-chaine(ch,p,i-p+1) caractères): chaine de caractères
Fin Si 1) [p1] Pour i de 1 à long(ch) faire
Insérer(mot,ch1,1) si(ch[i]=" ") alors
Fin pour mot" "+sous-chaine(ch,p,i-p)
i:compteur pi+1
Fin Renverser Fin Si
si(i=long(ch)) alors
motsous-chaine(ch,p,i-p+1)
Fin Si
Insérer(mot,ch1,1)
Fin pour
2) Renverser  ch1
T.D.O Locaux 3) Fin Renverser
Objet T/N Rôle
i Entier Compteur
p entier Déterminer la position de première lettre de
chaque mot
Ch1 Chaine de caractères Contient la phrase renversée
mot Chaine de caractères Contient un mot de la phrase
 Analyse de la Fonction SuppEspace
DEF FN SuppEspace(CH:chaine de caractères): chaine de caractères
Résultat : SuppEspace  ch
Si ch[long(ch)] = " " alors  Algorithme de la Fonction
Efface(ch,long(ch),1) SuppEspace
Fin Si 0) DEF FN SuppEspace(ch :chaine de
Ch =[i1]
caractères): chaine de caractères
Répéter
Si ch[i] = " " alors 1) [i1]Répéter
Si ch[i] = " " alors
Si i=1 alors p1
64 Bac Scientifique Sinon pi+1Idoudi Khaled Enseignant :
Fin si
[nb0,jp]
Tant que(ch[j]=" ")et(j≤long(ch))faire
 Si i=1 alors p1
Sinon pi+1
Fin si
[nb0,jp]
Tant que(ch[j]=" ")et(j≤long(ch))faire
jj+1
nbnb+1
Fin Tant que
Efface(ch,p,nb)
Fin Si
ii+1
Jusqu’à i>long(ch)
Fin SuppEspace

T.D.O Locaux
Objet T/N Rôle
i,j Entier Compteur
p Entier Déterminer une position de départ pour supprimer les espaces
nb Entier Calculer le nombre des espaces à supprimer
 Traduction Pascal
PROGRAM Renverser_chaine; FUNCTION Renverser(ch:string):string ;
USES wincrt ; VAR p,i :integer ;
VAR Ch :string ; Ch1,Mot :string ;
PROCEDURE Saisie(VAR ch :string) ; BEGIN
BEGIN P:=1;ch1:= '';
repeat for i:=1 to length(ch) do
begin
Write('Donner une chaine: ');
if ch[i]= ' ' then
Readln(ch) ; begin
until Upcase(ch[1]) in ['A'..'Z'] ; mot:= ' '+copy(ch,p,i-p);
END; ch1:=mot+ch1;
FUNCTION SuppEspace(ch:string):string ; p:=i+1;
VAR p,nb,i,j :integer ; end;
BEGIN if i=length(ch) then
i:=1; begin
Repeat mot:= copy (ch,p,i-p+1);
if ch[i] = ' ' then ch1:=mot+ch1;
begin end;
if i=1 then p:=1 end;
else p:=i+1; Renverser := ch1;
nb:=0;j:=p; END ;
while(ch[j]=' ')and(j<=length(ch))do BEGIN
begin Saisie(ch) ;
j:=j+1;

65 Bac Scientifique Idoudi Khaled Enseignant :

 nb:=nb+1; Ch :=SuppEspace(ch) ;
end; Write('Chaine résultat: ',
delete(ch,p,nb); Renverser(ch));
end;
i:=i+1; END.
until i>length(ch);
if ch[length (ch)] = ' ' then
delete(ch,length(ch),1);
SuppEspace := ch;
END ;

Exercice 14

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var p1,p2) PROC Remplir( var T) FN Max(p1,p2,T) FN Min(p1,p2,T) FN MoyArith(p1,p2,T)

 Analyse de programme principal :  Algorithme de programme

Nom de programme : Calcul principal:
Résultat: Ecrire("La moyenne arithmétique: ", 0) Début Calcul
FN MoyArith(p1,p2,T)) 1) PROC Saisie(p1,p2)
Ecrire("Le min: ",FN Min(p1,p2,T)) 2) PROC Remplir(T)
Ecrire("Le maximum: ",FN Max(p1,p2,T)) 3) PROC Afficher(p1,p2,T)
PROC Afficher(p1,p2,T) 4) Ecrire("Le maximum: ",FN
PROC Remplir(T) Max(p1,p2,T))
PROC Saisie(p1,p2) 5) Ecrire("Le min: ",FN
Fin Calcul Min(p1,p2,T))
T.D.N.T 6) Ecrire("La moyenne
Type arithmétique: ", FN
TAB= Tableau de taille 20 et de type entier MoyArith (n,T))
7) Fin Calcul
T.D.O Globaux
Objet T/N Rôle
P1,p2 Entier Saisir deux positions dans le tableau
T TAB Remplir les tableaux par N réels

66 Bac Scientifique Idoudi Khaled Enseignant :

 Remplir Procédure Remplir un tableau par N réels
Saisie Procédure Saisir les deux positions p1 et p2
Afficher les éléments du tableau compris entre p1 et
Afficher Procédure
p2
Max Fonction Déterminer le maximum entre p1 et p2
Min Fonction Déterminer le minimum entre p1 et p2
MoyArith Fonction Calculer la moyenne des entiers compris entre p1 et p2
 Analyse de la procédure Saisie

Algorithme de la procédure
DEF PROC SAISIE(VAR P1,P2 :ENTIER) Saisie
Résultat : p1,p2 0) DEF PROC SAISIE(VAR P1,P2:ENTIER)
x=[]Répéter
1) Répéter
p1=donnée("P1=: ")
p2=donnée("P2=: ") écrire("P1= ") lire(p1)
jusqu’à (p1≥1)ET(p2≤20)ET(p1≤p2) écrire("P2= ") lire(p2)
Fin Saisie jusqu’à (p1≥1)ET(p2≤20)ET(p1≤p2)
2) Fin Saisie
 Analyse de la procédure Remplir
DEF PROC REMPLIR(VAR T :TAB)
Résultat : T  Algorithme de la procédure Remplir
T=[]Pour i de 1 à 20 faire 0) DEF PROC REMPLIR(VAR T:TAB)
Répéter 1) Pour i de 1 à 20 faire
T[i]=donnée("T[",i, "]=") Répéter
jusqu’à T[i]≥0 écrire("T[",i, "]=")
Fin Pour lire(T[i])
i : compteur jusqu’à T[i]≥0
Fin Remplir Fin Pour
T.D.O Locaux 2) Fin Remplir
Objet T/N Rôle
i Entier Compteur
Analyse de la Fonction MoyArith
DEF FN MoyArith(P1,P2:ENTIER ; T:TAB): REEL
Résultat : Moyarith  s/(p1-p2+1)
S=[s0]
Pour i de p1 à p2 faire  Algorithme de la Fonction MoyArith
Ss+T[i] 0) DEF FN MoyArith(P1,P2:ENTIER;T:TAB):RÉEL
Fin pour 1) [s0]
i:compteur 2) Pour i de p1 à p2 faire
Fin MoyArith Ss+T[i]
Fin pour
3) MoyArith s/(p1-p2+1)
4) Fin MoyArith
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur

67 Bac Scientifique Idoudi Khaled Enseignant :

s Réel Calculer la somme des éléments d’un vecteur
 Analyse de la Fonction Max
DEF FN Max(P1,P2:ENTIER,T:TAB):ENTIER
Résultat : Max  m
m=[mT[p1]]  Algorithme de la Fonction Max
Pour i de p1 à p2 faire 0) DEF FN Max(P1,P2:ENTIER,T:TAB):ENTIER
si(T[i]>m) alors 1) [mT[p1]]
mT[i] 2) Pour i de p1 à p2 faire
Fin Si si(T[i]>m) alors
Fin pour mT[i]
i:compteur Fin Si
Fin Max Fin pour
3) Max  m
4) Fin Max

T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
m Réel Déterminer la valeur maximale d’une liste des valeurs
 Analyse de la Fonction Min
DEF FN Min(P1,P2:ENTIER,T:TAB):ENTIER  Algorithme de la Fonction Min
Résultat : Max  m
0) DEF FN Min(P1,P2:ENTIER,T:TAB):ENTIER
m=[mT[p1]]
Pour i de p1 à p2 faire 1) [mT[1]]
si(T[i]<m) alors 2) Pour i de 1 à n faire
mT[i] si(T[i]<m) alors
Fin Si mT[i]
Fin pour Fin Si
i:compteur Fin pour
Fin Min 3) Min  m
T.D.O Locaux 4) Fin Min
Objet T/N Rôle
i Entier Compteur
m Réel Déterminer la valeur minimale d’une liste des valeurs
 Analyse de la procédure Afficher
DEF PROC AFFICHER(P1,P2 :ENTIER,T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de p1 à p2 faire
Afficher
Ecrire("T[",i, "]=",T[i])
Fin Pour 0) DEF PROC AFFICHER(P1,P2:ENTIER,T:TAB)
i : compteur 1) Pour i de p1 à p2 faire
Fin Afficher Ecrire("T[",i, "]=",T[i])
Fin Pour
T.D.O Locaux 2) Fin Afficher

68 Bac Scientifique Idoudi Khaled Enseignant :

 Objet T/N Rôle
i Entier Compteur

 Traduction Pascal
PROGRAM Calcul; PROCEDURE Saisie(VAR p1,p2:integer) ;
USES wincrt ; BEGIN
TYPE TAB=Array[1..20] of integer ; repeat
VAR Write('P1: '); Readln(p1) ;
n:integer ; Write('P2: '); Readln(p2) ;
T :TAB ; until(p1>=5)and(p2<=20)and(p1<=p2);
FUNCTION MoyArith END;
(p1,p2:integer;T:TAB) :real; PROCEDURE Remplir(VAR T:TAB);
VAR i :integer ; VAR i :integer ;
S:integer ; BEGIN
BEGIN for i :=1 to 20 do
S :=0 ; repeat
FOR i :=p1 to p2 do Write('T[',i, ']= ') ;
S :=s+ T[i]; Readln(T[i]) ;
MoyArith:= s/(p2-p1+1) ; until T[i]>=0 ;
END; END;
FUNCTION Max(p1,p2:integer;T:TAB): PROCEDURE Afficher(p1,p2:integer ;
integer; VAR T:TAB);
VAR VAR i :integer ;
i,m :integer ; BEGIN
BEGIN for i :=p1 to p2 do
m := T[p1] ; Write('T[',i, ']= ',T[i]) ;
FOR i :=p1+1 to p2 do END;
if(T[i]>m) then
m := T[i] ; BEGIN
Max :=m ;
Saisie(p1,p2) ;
END;
FUNCTION Min(p1,p2:integer;T:TAB): Remplir(T);
integer; Afficher(p1,p2,T) ;
VAR Write('Le maximum: ',Max(p1,p2,T));
i,m :integer ; Write('Le minimum: ',Min(p1,p2,T));
BEGIN Write('La moyenne arithmétique: ',
m := T[p1] ; MoyArith(n,T):2:3);
FOR i :=p1 to p2 do
END.
if(T[i]<m) then
m := T[i] ;
Min :=m ;
END;

69 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 15

 Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N) PROC Afficher(N,T)
Remplir( N,var T) PROC Trier(N,T2,var T1)

FN Min(p,N,T)

 Analyse de programme principal :

Nom de programme : Tri

 Algorithme de programme
principal:
Résultat : PROC Afficher(n,T2)
0) Début Tri
PROC Trier(n,T1,T2) 1) PROC Saisie(n)
PROC Remplir(n,T1) 2) PROC Remplir(n,T1)
PROC Saisie(n) 3) PROC Trier(n,T1,T2)
Fin Tri 4) PROC Afficher(n,T2)
5) Fin Tri
T.D.N.T
Type
TAB= Tableau de taille 20 et de type caractère
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
T1 TAB Remplir le tableau par N lettres majuscules
T2 TAB Contient les éléments de T1 dans l’ordre croissant
Afficher Procédure Afficher un tableau
Remplir Procédure Remplir le tableau par n lettres majuscules.
Saisie Procédure Saisir la taille du tableau
Trier Procédure Trier le tableau T dans l’ordre croissant
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x
0) DEF PROC SAISIE(VAR X :ENTIER)
x=[]Répéter
x=donnée("Donner la valeur de N : ") 1) Répéter
jusqu’à (x≥5)ET(x≤20) écrire("Donner la valeur de N: ")
Fin Saisie lire(x)
jusqu’à (x≥5)ET(x≤30)
2) Fin Saisie

 Analyse de la procédure Remplir

70 Bac Scientifique Idoudi Khaled Enseignant :

DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
répéter 0) DEF PROC REMPLIR(N :ENTIER ;VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
Jusqu’à Majus(T[i])dans["A".."Z"] répéter
Fin Pour écrire("T[",i, "]=")
i : compteur lire(T[i])
Fin Remplir jusqu’à Majus(T[i])dans["A".."Z"]
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER ;T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à N faire Afficher
Ecrire("T[",i, "]=",T[i]) 0) DEF PROC AFFICHER(N :ENTIER ;T:TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur Ecrire("T[",i, "]=",T[i])
Fin Afficher Fin Pour
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure Trier
DEF PROC TRIER(N:ENTIER;T1:TAB;VAR T2:TAB)
Résultat : T
T2 =[]Pour i de 1 à N faire  Algorithme de la procédure Trier
posminFN Min(N,T1) 0) DEF PROC TRIER(N:ENTIER;T1:TAB;VAR
T2[i]T1[posmin] T2:TAB)
T1[posmin]"*" 1) Pour i de 1 à N faire
Fin Pour posminFN Min(N,T1)
i : compteur T2[i]T1[posmin]
Fin Trier T1[posmin]"*"
Fin Pour
2) Fin Trier
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Min Fonction Déterminer la position de minimum dans un tableau
posmin Entier Contient la position de minimum dans un tableau

 Analyse de la Fonction Min

71 Bac Scientifique
 Algorithme de la Fonction Min
Idoudi Khaled Enseignant :
0) DEF FN Min(n:ENTIER ;T:TAB): ENTIER
1) [posmin1]
Pour i de 2 à n faire
DEF FN Min(n:ENTIER ;T:TAB):ENTIER
Résultat : Min  posmin
posmin =[posmin1]
Pour i de 2 à n faire
Si T[i]≠"*" alors
Si (T[i]<T[posmin]) ou
(T[posmin]="*") alors
posmini
Fin Si
Fin Si
Fin pour
i:compteur
Fin Min

T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
posmin entier Déterminer la position du petit caractère dans un tableau
 Traduction Pascal
PROGRAM Tri; PROCEDURE Trier(n:integer ;T1 :TAB ;
USES wincrt ; VAR T2 :TAB) ;
TYPE TAB=Array[1..20] of char ; VAR posmin,i :integer ;
VAR N:integer ; FUNCTION Min(n:integer;T:TAB):integer;
T1,T2 :TAB ; VAR posmin,i :integer ;
PROCEDURE Saisie(VAR x :integer) ; BEGIN
BEGIN posmin:=1;
repeat for i := 2 to n do
if T[i]<>'*' then
Write('Donner la valeur de N: ');
if (T[i]<T[posmin]) or
Readln(x) ; (T[posmin]="*") then
until(x>=5)and(x<=20); Posmin :=i ;
END; Min := posmin;
PROCEDURE Remplir(n:integer;VAR T:TAB); END;
VAR i :integer ; BEGIN
BEGIN for i :=1 to n do
for i :=1 to n do begin
repeat Posmin := Min(N,T1) ;
Write('T[',i, ']= ') ; T2[i]:=T1[posmin];
Readln(T[i]) ; T1[posmin]:='*';
until Upcase(T[i])in['A'..'Z'] ; end;
END; END;
PROCEDURE Afficher(n:integer ;T :TAB) ; BEGIN
VAR i :integer ; Saisie(n) ; Remplir(n,T1);
BEGIN Trier(n,T1,T2) ;
for i :=1 to n do Write(T[i],' ') ; Afficher(n,T2) ;
END; END.

72 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 16

 Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N) PROC Afficher(N,T)
Remplir( N,var T) PROC Trier(N,T2,var T1)

FN Min(p,N,T)

 Analyse de programme principal :

Nom de programme : Tri

 Algorithme de programme
principal:
Résultat : PROC Afficher(n,B)
0) Début Tri
PROC Trier(n,A,B) 1) PROC Saisie(n)
PROC Remplir(n,A) 2) PROC Remplir(n,A)
PROC Saisie(n) 3) PROC Trier(n,A,B)
Fin Tri 4) PROC Afficher(n,B)
5) Fin Tri
T.D.N.T
Type
TAB= Tableau de taille 25 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
A TAB Remplir le tableau par N entiers
B TAB Contient les éléments de T1 dans l’ordre croissant
Afficher Procédure Afficher un tableau
Remplir Procédure Remplir le tableau par n entiers.
Saisie Procédure Saisir la taille du tableau
Trier Procédure Trier le tableau T dans l’ordre croissant
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR X :ENTIER) Saisie
Résultat : x
0) DEF PROC SAISIE(VAR X :ENTIER)
x=[]Répéter
x=donnée("Donner la valeur de N : ") 1) Répéter
jusqu’à (x>5)ET(x<25) écrire("Donner la valeur de N: ")
Fin Saisie lire(x)
jusqu’à (x>5)ET(x<25)
2) Fin Saisie

 Analyse de la procédure Remplir

73 Bac Scientifique Idoudi Khaled Enseignant :

DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
répéter 0) DEF PROC REMPLIR(N :ENTIER ;VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
Jusqu’à T[i]≥0 répéter
Fin Pour écrire("T[",i, "]=")
i : compteur lire(T[i])
Fin Remplir jusqu’à T[i]≥0
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER ;T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à N faire Afficher
Ecrire("T[",i, "]=",T[i]) 0) DEF PROC AFFICHER(N :ENTIER ;T:TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur Ecrire("T[",i, "]=",T[i])
Fin Afficher Fin Pour
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure Trier
DEF PROC TRIER(N:ENTIER;A:TAB;VAR B:TAB)
Résultat : T
T2 =[]Pour i de 1 à N faire  Algorithme de la procédure Trier
posmaxFN Max(N,T1) 0) DEF PROC TRIER(N:ENTIER;A:TAB;VAR
T2[i]T1[posmax] B:TAB)
T1[posmax]-1 1) Pour i de 1 à N faire
Fin Pour posmaxFN Max(N,T1)
i : compteur T2[i]T1[posmax]
Fin Trier T1[posmax]-1
Fin Pour
2) Fin Trier
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Max Fonction Déterminer la position de maximum dans un tableau
posmax Entier Contient la position de maximum dans un tableau

 Analyse de la Fonction Max

74 Bac Scientifique
 Algorithme de la Fonction Max
Idoudi Khaled Enseignant :
0) DEF FN Max(n:ENTIER ;T:TAB): ENTIER
1) [posmax1]
Pour i de 2 à n faire
DEF FN Max(n:ENTIER ;T:TAB):ENTIER
Résultat : Max  posmax
posmax =[posmax1]
Pour i de 2 à n faire
Si T[i]≠-1 alors
Si (T[i]>T[posmax]) ou
(T[posmax]=-1) alors
posmaxi
Fin Si
Fin Si
Fin pour
i:compteur
Fin Max

T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
posmax entier Déterminer la position du grand caractère dans un tableau
 Traduction Pascal
PROGRAM Tri; PROCEDURE Trier(n:integer ;A:TAB; VAR
USES wincrt ; B:TAB) ;
TYPE TAB=Array[1..25] of integer ; VAR posmax,i :integer ;
VAR N:integer ; FUNCTION Max(n:integer;T:TAB):integer;
T1,T2 :TAB ; VAR posmax,i :integer ;
PROCEDURE Saisie(VAR x :integer) ; BEGIN
BEGIN posmax:=1;
repeat for i := 2 to n do
if T[i]<>-1 then
Write('Donner la valeur de N: ');
if (T[i]<T[posmax]) or
Readln(x) ; (T[posmax]=-1) then
until(x>5)and(x<25); Posmax :=i ;
END; Max := posmax;
PROCEDURE Remplir(n:integer;VAR T:TAB); END;
VAR i :integer ; BEGIN
BEGIN for i :=1 to n do
for i :=1 to n do begin
repeat Posmax := Max(N,A) ;
Write('T[',i, ']= ') ; B[i]:=A[posmax];
Readln(T[i]) ; A[posmax]:=-1;
until T[i]>=0; end;
END; END;
PROCEDURE Afficher(n:integer ;T :TAB) ; BEGIN
VAR i :integer ; Saisie(n) ; Remplir(n,A);
BEGIN Trier(n,A,B) ; Exercice 17
for i :=1 to n do Write(T[i],' ') ; Afficher(n,B) ;
END; END.
 Décomposition modulaire du problème

75 Bac Scientifique Idoudi Khaled Enseignant :

 Programme Principal

PROC Saisie(var n) FN Amis (n,m) FN SomDiv (x)

 Analyse de programme principal : 

Algorithme de programme
principal:
Nom de programme : Nombre_Amis
0) Début Nombre_Amis
Résultat : trait
1) PROC Saisie(n)
Trait=[]Si FN Amis(n,m) alors
2) PROC Saisie(m)
Ecrire(n," et ",m, " sont amis")
3) Si FN Amis(n,m) alors
Sinon
Ecrire(n," et ",m, " sont
Ecrire(n," et ",m," ne sont pas amis")
amis")
Fin Si
Sinon
PROC Saisie(m)
Ecrire(n," et ",m," ne
PROC Saisie(n)
sont pas amis")
Fin Nombre_Amis
Fin Si
4) Fin Nombre_Amis
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la valeur de N
M Entier Stocker la valeur de M
Saisie Procédure Saisir un entier naturel
Amis Fonction Vérifier si n et m sont amis ou non
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR X :ENTIER)  Algorithme de la procédure Saisie

Résultat : x 0) DEF PROC SAISIE(VAR X :ENTIER)
x=[] 1) Répéter
Répéter écrire("Donner un entier : ")
x=donnée("Donner la valeur de N : ") lire(x)
jusqu’à X≥0 jusqu’à X≥0
Fin Saisie 2) Fin Saisie

 Analyse de la fonction Amis

DEF FN AMIS(X,Y :ENTIER) :BOOLEEN  Algorithme de la fonction Amis
0) DEF FN AMIS(X,Y :ENTIER) :BOOLEEN
76 Bac Scientifique 1) S1FN SomDiv(x)
Idoudi Khaled Enseignant :
2) S2FN SomDiv(y)
3) Amis(s1=y)et(s2=x)
4) Fin Amis
Résultat : amis(s1=y)et(s2=x)
S1FN SomDiv(x)
S2FN SomDiv(y)
Fin Amis

T.D.O Locaux
Objet T/N Rôle
S1 Entier Contient la somme des diviseurs de x sauf lui même
S2 Entier Contient la somme des diviseurs de y sauf lui même
SomDiv Fonction Calculer la somme des diviseurs d’un nombre
Analyse de la Fonction SomDiv
DEF FN SomDiv(X:ENTIER) : ENTIER
Résultat : SomDivS  Algorithme de la Fonction SomDiv
Trait=[] 0) DEF FN SomDiv(X:ENTIER) : ENTIER
S=[s0]Pour i de 1 à x div 2 faire
1) [s0]
Si(x mod i = 0) alors
2) Pour i de 1 à x div 2 faire
SS+i
Si(x mod i = 0) alors
Fin Si
SS+i
Fin Pour
Fin Si
i : compteur
Fin Pour
Fin SomDiv
3) SomDivS
4) Fin SomDiv
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
S Entier Calculer la somme des diviseurs de x
 Traduction Pascal
PROGRAM Nombre_Amis; FUNCTION Amis(x,y:integer):boolean;
USES wincrt ; VAR S1,s2 :integer ;
VAR BEGIN
n,m :integer ; S1:=SomDiv(x);
PROCEDURE Saisie(VAR x :integer) ; S2:=SomDiv(y);
BEGIN Amis:=(s1=y)and(s2=x);
repeat END;
Write('Donner un entier: '); BEGIN
Readln(x) ; Saisie(n) ;
until(x>=0); Saisie(m) ;
END; if Amis(n,m) then
FUNCTION SomDiv(x :integer) :integer ; write(n,' et ',m, ' sont amis')
VAR i,S :integer ; else
BEGIN write (n,' et ',m,' ne sont pas
S :=0 ;
amis');
for i :=1 to x div 2 do
If(x mod i = 0) then END.
S :=S+i ;

77 Bac Scientifique E x e r cEnseignant

Idoudi Khaled i c e 1 8:
 SomDiv := S ;
END ;

 Décomposition modulaire du problème

Programme Principal

PROC Afficher (n,m)

PROC Saisie(var n,m)

 Analyse de programme principal :

 Algorithme de programme
principal:
Nom de programme : Ex18 0) Début Ex18
Résultat : PROC Afficher(n,m) 1) PROC Saisie(n,m)
PROC Saisie(n,m) 2) PROC Afficher(n,m)
Fin Ex18 3) Fin Ex18

T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la valeur de N
M Entier Stocker la valeur de M
Saisie Procédure Saisir deux entiers n et m
Afficher Procédure afficher tous les entiers de l’intervalle [1, m] en
remplaçant par le caractère "*" tous les diviseurs de n
ainsi que tous les entiers comportant dans leurs
écritures le chiffre des unités de n
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR X,Y :ENTIER) 

Algorithme de la procédure Saisie
Résultat : x,Y 0) DEF PROC SAISIE(VAR X,Y :ENTIER)
x=[] 1) Répéter
Répéter écrire("Donner la valeur de N : ")
x=donnée("Donner la valeur de N : ") lire(x)
y=donnée("Donner la valeur de M : ") écrire("Donner la valeur de M : ")
jusqu’à (X dans [100..500]) et lire(y)
(Y dans [10..99]) jusqu’à (X dans [100..500]) et
Fin Saisie (Y dans [10..99])
2) Fin Saisie
 Analyse de la procédure Afficher

78 Bac Scientifique Idoudi Khaled Enseignant :

DEF PROC AFFICHER(N,M :ENTIER)
Résultat : Trait  Algorithme de la procédure
Trait=[]pour i de 1 à m faire Afficher
Convch(i,ch2) 0) DEF PROC AFFICHER(N,M :ENTIER)
Si (n mod i =0)ou(pos(ch1,ch2)≠0)alors 1) Convch(m mod 10,ch1)
Ecrire("*") 2) pour i de 1 à m faire
Sinon Convch(i,ch2)
Ecrire(i) Si (n mod i=0) ou (pos(ch1,ch2)≠0)
Fin Si alors Ecrire("*")
Fin pour Sinon Ecrire(i)
Convch(m mod 10,ch1) Fin Si
Fin Afficher Fin pour
3) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
I Entier compteur
Ch1,ch2 Chaine de Chaines
caractères auxiliaires
 Traduction Pascal
PROGRAM ex18; BEGIN
USES wincrt ; Saisie(n,m) ;
VAR Afficher(n,m) ;
n,m :integer ; END.
PROCEDURE Saisie(VAR x,y :integer) ;
BEGIN
repeat
Write('Donner la valeur de N: ');
Readln(x) ;
Write('Donner la valeur de M: ');
Readln(y) ;
until(x>=100)and(x<=500)and(y in [10..99]);
END;
PROCEDURE Afficher(n,m :integer);
VAR i:integer ;
Ch1,ch2 :string ;
BEGIN
str(m mod 10,ch1);
for i :=1 to m do
begin
str(i,ch2);
if (n mod i=0) or (pos(ch1,ch2)<>0) then
write('*')
else write(i);
end;
Exercice 19
END ;
 Décomposition modulaire du problème

Programme Principal
79 Bac Scientifique Idoudi Khaled Enseignant :
  Analyse de programme principal :  Algorithme de programme
Nom de programme : Fréquence_Lettre principal:
Résultat: PROC Afficher(n,T1,T2) 0) Début Fréquence_Lettre
PROC Frequence (ch,n,T1,T2) 1) PROC Saisie(ch)
PROC Saisie(ch) 2) PROC Frequence (ch,n,T1,T2)
Fin Fréquence_Lettre 3) PROC Afficher(n,T1,T2)
4) Fin Fréquence_Lettre
T.D.N.T
Type
TChar= Tableau de taille 20 et de type caractère
TInt= Tableau de taille 20 et de type entier
T.D.O Globaux
Objet T/N Rôle
Ch Chaine de caractère stocker une chaine de caractère
T1 TChar Stocker les lettres utilisées dans la phrase
Stocker les fréquences des lettres utilisées
T2 TInt
dans la phrase
Saisie Procédure Saisir une chaine de caractère
Remplir deux tableaux respectivement par des
Frequence Procédure
lettres et leurs fréquences dans la phrase.
Afficher la lettre alphabétique la plus
Afficher Procédure
utilisée dans un texte
 Analyse de la procédure Saisie  Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères) Saisie
Résultat : ch 0) DEF PROC SAISIE(VAR ch:chaine
ch=[]Répéter de caractères)
ch=donnée("Donner une chaine : ") 1) Répéter
jusqu’à long(ch) dans [5..20] écrire("Donner une chaine : ")
Fin Saisie lire(ch)
jusqu’à long(ch) dans [5..20]
 Analyse de la procédure Fréquence Fin Saisie
2)
DEF PROC FREQUENCE (CH:chaine de caractères;var n:entier;var
T1:TChar;var T2:TInt)
 Algorithme de la procédure
Fréquence
80 Bac Scientifique Idoudi(CH:chaine
0) DEF PROC FREQUENCE Khaled Enseignant
de :
caractères; var n:entier; var
T1:TChar;var T2:TInt)
1) [i1,ch1ch]répéter
Résultat : T1,T2,n
ni-1
(T1,T2) =[i1,ch1ch]
répéter
T1[i]Ch1[i]
PROC Compter(ch1,ch1[i],f)
T2[i]f
ii+1
jusqu’à ch1=""

Fin Fréquence

T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
F Entier Contient la fréquence d’un caractère dans une chaine
Compter Procédure Compter la fréquence d’un caractère dans une chaine
Analyse de la procédure Compter
DEF PROC Compter (var CH:chaine de caractères; c:caractère; var
f:entier)
Résultat : ch,f
 Algorithme de la procédure Compter
[f0] 0) DEF PROC Compter (var CH:chaine de
Tant que Pos(c,ch)≠0 faire caractères; c:entier;var f :entier)
ff+1 1) [f0]
Efface(ch,Pos(c,ch),1) Tant que Pos(c,ch)≠0 faire
Fin Tant que ff+1
Efface(ch,Pos(c,ch),1)
Fin Compter Fin Tant que
2) Fin Compter

 Analyse de la procédure Afficher

DEF PROC AFFICHER(N :ENTIER ;T1 :TCHAR ;T2 :TINT)
Résultat : Trait
Trait=[]Pour i de 1 à N faire
 Algorithme de la procédure Afficher
Si (T2[i]=T2[posmax]) alors 0) DEF PROC AFFICHER(N :ENTIER ;
Ecrire(T1[i]," f=",T2[i]) T1 :TCHAR ;T2 :TINT)
Fin si 1) PosmaxFN MAX(n,T2)
Fin Pour 2) Pour i de 1 à N faire
PosmaxFN MAX(n,T2) Si (T2[i]=T2[posmax]) alors
i : compteur Ecrire(T1[i]," f=",T2[i])
Fin Afficher Fin si
Fin Pour
T.D.O Locaux 3) Fin Afficher
Objet T/N Rôle
i Entier Compteur

81 Bac Scientifique Idoudi Khaled Enseignant :

 posmax Entier Contient la position du la fréquence la plus grande
 Analyse de la Fonction Max
DEF FN Max(n:ENTIER ;T:TINT):ENTIER
 Algorithme de la Fonction Max
Résultat : Mqx  posmax
0) DEF FN Max(n:ENTIER;T:TINT) :ENTIER
posmax =[posmax1]
Pour i de 2 à n faire 1) [posmax1]
Si T[i]>T[posmax] alors Pour i de 2 à n faire
posmaxi Si T[i]>T[posmax] alors
Fin Si posmaxi
Fin pour Fin Si
i:compteur Fin pour
Fin Max 2) Max  posmax
3) Fin Max
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
posmax entier Déterminer la position du la fréquence la plus grande
 Traduction Pascal
PROGRAM Frequence_Lettre; PROCEDURE Compter(var ch:string; c:char;
USES wincrt ; var f :integer);
TYPE Tint= array[1..20] of integer ; BEGIN
TChar=array[1..20] of char ; f:=0;
VAR Ch :string ; while Pos(c,ch)<>0 do
T1 :TChar ;T2 :Tint ; begin
N :integer ; f:=f+1;
PROCEDURE Saisie(VAR ch :string) ; delete(ch,Pos(c,ch),1);
BEGIN End;
repeat END ;
Write('Donner une chaine: '); PROCEDURE Frequence(ch:string ; var
Readln(ch) ; n :integer ;var T1 :TChar ;var T2 :Tint);
VAR i,f :integer ;
until length(ch) in [5..20] ;
BEGIN
END; i:=1;ch1:=ch;
PROCEDURE Afficher(n:integer;T1:TChar Repeat
;T2:TInt); T1[i] :=Ch[i] ;
VAR i,posmax :integer ; Compter(ch1,ch[i],f) ;
FUNCTION Max(n:integer;T:TInt):integer; T2[i] :=f ;
VAR posmax,i :integer ; i:=i+1;
BEGIN
until ch1 = '';
posmax:=1;
n:=i-1;
for i := 2 to n do
if T[i]<T[posmax]then END ;
Posmax :=i ;
Max := posmax;
END; BEGIN
BEGIN
Saisie(ch);
Posmax:= MAX(n,T2);
for i:=1 to n do Frequence (ch,n,T1,T2);

82 Bac Scientifique Idoudi Khaled Enseignant :

 if (T2[i]=T2[posmax]) then Afficher(n,T1,T2);
writeln(T1[i],' f=',T2[i]) END.
END ;

Exercice 20

 Décomposition modulaire du problème

Programme Principal

FN Coder (ch)
PROC Saisie(var ch)

PROC Permut (c1,c2)

 Analyse
de programme principal :  Algorithme de programme
Nom de programme : Codage principal:
Résultat: écrire("La chaine après codage :", 0) Début Codage
FN Coder(ch)) 1) PROC Saisie(ch)
PROC Saisie(ch) 2) écrire("La chaine après
Fin Codage codage :", FN Coder(ch))
3) Fin Codage
T.D.O Globaux
Objet T/N Rôle
ch Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
permuter chaque caractère d’indice pair avec
Coder Fonction
le caractère qui le précède
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR CH:chaine de caractères)  Algorithme de la procédure

Résultat : ch Saisie
ch=[]Répéter 0) DEF PROC SAISIE(VAR ch:chaine
ch=donnée("Donner une chaine : ") de caractères)
jusqu’à long(ch) > 1 1) Répéter
Fin Saisie écrire("Donner une chaine : ")
lire(ch)
jusqu’à long(ch) > 1
2) Fin Saisie
 Analyse de la fonction Coder
DEF FN Coder (CH:chaine de caractères) : chaine de caractères
Résultat : Coderch
For i de 1 à long(ch) faire  Algorithme de la Fonction Coder
0) DEF FN Coder(CH: chaine de
caractères) : chaine de caractères
83 Bac Scientifique Idoudi Khaled Enseignant :
1) For i de 1 à long(ch) faire
Si i mod 2 = 0 alors
PROC Permut(ch1[i-1],ch1[i])
Fin Si
 Si i mod 2 = 0 alors
PROC Permut(ch1[i-1],ch1[i])
Fin Si
Fin pour
i :Compteur
Fin Coder

T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
Permut Procédure permuter deux caractères d’une chaine
 Analyse de la procédure Permut
DEF PROC PERMUT(VAR X,Y :CARACTERE)
Résultat : x,y  Algorithme de la procédure Permut
auxx 0) DEF PROC PERMUT(VAR X,Y : CARACTERE)
xy 1) Auxx
yaux 2) Xy
Fin Permut 3) Yaux
T.D.O Locaux 4) Fin Permut
Objet T/N Rôle
aux Entier Variable auxiliaire
 Traduction Pascal
PROGRAM Codage; PROCEDURE Saisie(VAR ch :string) ;
USES wincrt ; BEGIN
VAR Ch :string ; repeat
Function Coder(ch :string) :string;
Write('Donner une chaine: ');
VAR i:integer ;
PROCEDURE Permut(VAR x,y:char); Readln(ch) ;
VAR aux :char ; until length(ch) > 1 ;
BEGIN END;
aux :=x ; BEGIN
x :=y ;
y :=aux ; Saisie(ch);
END; writeln('La chaine après codage :',
BEGIN Coder(ch))
for i:=1 to length(ch) do END.
if i mod 2 = 0 then
Permut(ch1[i-1],ch1[i]) ;
Coder:=ch;
Exercice 21
END ;
 Décomposition modulaire du problème

Programme Principal

84 Bac Scientifique Idoudi Khaled Enseignant :

FN Lancer( ) PROC Jouer (var ScoreJ1, ScoreJ2)

  Algorithme de programme
 Analyse de programme principal : principal:
Nom de programme : Jeu_Dé 0) Début Jeu_Dé
Résultat: Trait 1) PROC Jouer(ScoreJ1, ScoreJ2)
Trait=[] Si ScoreJ1=10 alors 2) Ecrire("Joueur1=",ScoreJ1,"
écrire("Le joueur 1 gagne la partie") Joueur2=",ScoreJ2)
Sinon 3) Si ScoreJ1=10 alors
écrire("Le joueur 2 gagne la partie") écrire("Le joueur 1 gagne la
Fin Si partie")
Ecrire("Joueur1=",ScoreJ1," Joueur2=", Sinon
ScoreJ2) écrire("Le joueur 2 gagne la
PROC Jouer(ScoreJ1, ScoreJ2) partie")
Fin Jeu_Dé Fin Si
4) Fin Jeu_Dé
T.D.O Globaux
Objet T/N Rôle
ScoreJ1 Entier Stocker le score de joueur 1
ScoreJ2 Entier Stocker le score de joueur 2
Jouer Procédure Contrôler le déroulement de jeu de dé
 Analyse de la procédure Jouer

DEF PROC JOUER(VAR scj1,SCJ2 :ENTIER)

Résultat : ScJ1,ScJ2  Algorithme de la procédure Saisie
[ScJ10, ScJ20] 0) DEF PROC JOUER(VAR Scj1,SCJ2 :ENTIER)
Répéter 1) [ScJ10, ScJ20]
N1 FN Lancer Répéter
N2 FN Lancer N1 FN Lancer
Ecrire("Joueur 1 obtient:",N1, N2 FN Lancer
" Joueur 2 obtient:",N2) Ecrire("Joueur 1 obtient:",N1,
Si N1>N2 alors ScJ1ScJ1+1 " Joueur 2 obtient:",N2)
Sinon ScJ2ScJ2+1 Si N1>N2 alors ScJ1ScJ1+1 Fin Si
Fin Si Si N1<N2 alors ScJ2ScJ2+1 Fin Si
jusqu’à (ScJ1 = 10) ou (ScJ2 = 10) jusqu’à (ScJ1 = 10) ou (ScJ2 = 10)
Fin Jouer 2) Fin Jouer

T.D.O Locaux
Objet T/N Rôle
N1 Entier Stocker la valeur de la face obtenue par le joueur 1
N2 Entier Stocker la valeur de la face obtenue par le joueur 2

85 Bac Scientifique Idoudi Khaled Enseignant :

 Lancer Fonction Générer un nombre aléatoire entre 1 et 6
 Analyse de la fonction Lancer
DEF FN Lancer: entier
 Algorithme de la Fonction Lancer
Résultat : Lancer  Random(6)+1
0) DEF FN Lancer: entier
Fin Lancer 1) LancerRandom(6)+1
2) Fin Lancer
 Traduction Pascal
PROGRAM Jeu_De; BEGIN
USES wincrt ; Jouer(ScoreJ1, ScoreJ2);
VAR ScoreJ1,ScoreJ2 :integer ; writeln('Joueur1=',ScoreJ1, '
PROCEDURE Jouer(ScJ1, ScJ2:integer);
Joueur2=',ScoreJ2);
VAR N1,N2:integer ;
FUNCTION Lancer :integer ; if ScoreJ1=10 alors
BEGIN writeln ('Le joueur 1 gagne la partie')
Lancer :=Random(6)+1 ; else
END; writeln ('Le joueur 2 gagne la partie');
BEGIN END.
ScJ1:=0; ScJ2:=0;
Randomize;
repeat Random(6) permet de générer un nombre
N1 :=Lancer ; aléatoire compris entre 0 et 5
N2 :=Lancer ;
writeln('Joueur 1 obtient:',N1,
' Joueur 2 obtient:',N2) ;
if N1>N2 then ScJ1 :=ScJ1+1
else ScJ2 :=ScJ2+1 ;
until (ScJ1 = 10) or (ScJ2 = 10);
END ;

Exercice 22

 Décomposition modulaire du problème

Programme Principal

PROC Afficher (ch)

PROC Saisie(var ch)

 Analyse de programme principal :  Algorithme de programme

Nom de programme : chaine principal:
Résultat: PROC Afficher(chm)
0) Début chaine
PROC Saisie(chm)
1) PROC Saisie(chm)
2) PROC Afficher(chm)
86 Bac Scientifique 3) Fin Idoudi
chaineKhaled Enseignant :
Fin chaine

T.D.O Globaux
Objet T/N Rôle
chm Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
Afficher Procédure Afficher une chaine
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères)
Saisie
Résultat : ch
ch=[]Répéter 0) DEF PROC SAISIE(VAR ch:chaine
ch=donnée("Donner une chaine : ") de caractères)
jusqu’à long(ch) ≥ 5 1) Répéter
Fin Saisie écrire("Donner une chaine : ")
lire(ch)
jusqu’à long(ch) ≥ 5
 Analyse de la procédure Afficher 2) Fin Saisie
DEF PROC AFFICHER(CH :chaine de caractères)
Résultat : Trait
Trait=[]Pour i de 1 à long(ch) faire
 Algorithme de la procédure
Ecrire(sous-chaine(ch,1,i)+ Afficher
sous-chaine(ch,long(ch)-i+1,i)) 0) DEF PROC AFFICHER(CH: chaine de
Fin Pour caractères)
i : compteur 1) Pour i de 1 à long(ch) faire
Fin Afficher Ecrire(sous-chaine(ch,1,i)+
T.D.O Locaux sous-chaine(ch,long(ch)-i+1,i))
Objet T/N Rôle Fin Pour
i Entier Compteur 2) Fin Afficher

 Traduction Pascal
PROGRAM chaine ; PROCEDURE Saisie(VAR ch :string) ;
USES wincrt ; BEGIN
VAR Chm :string ; REPEAT
PROCEDURE Afficher(ch :string) ; Write('Donner une chaine: ');
VAR i :integer ; Readln(ch) ;
BEGIN UNTIL length(ch)>=5 ;
for i:=1 to length(ch) do END;
writeln(copy(ch,1,i)+copy(ch, length(ch)- BEGIN
i+1, i) ) ; Saisie(chm) ; E x e r c i c e 2 3
END ; Afficher(chm) ;
END.

87 Bac Scientifique Idoudi Khaled Enseignant :

  Décomposition modulaire du problème

Programme Principal

PROC Afficher (ch)

PROC Saisie(var ch)

 Analyse de programme principal :  Algorithme de programme

Nom de programme : chaine principal:
Résultat: PROC Afficher(ch)
0) Début chaine
PROC Saisie(ch)
1) PROC Saisie(ch)
Fin chaine
2) PROC Afficher(ch)
T.D.O Globaux 3) Fin chaine
Objet T/N Rôle
ch Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
Afficher Procédure Afficher une chaine sous forme d’un triangle
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères)
Saisie
Résultat : ch
ch=[]Répéter 0) DEF PROC SAISIE(VAR ch:chaine
ch=donnée("Donner une chaine : ") de caractères)
jusqu’à long(ch) ≥ 3 1) Répéter
Fin Saisie écrire("Donner une chaine : ")
lire(ch)
jusqu’à long(ch) ≥ 3
 Analyse de la procédure Afficher 2) Fin Saisie
DEF PROC AFFICHER(CH :chaine de caractères)
Résultat : Trait
Trait=[]Pour i de 1 à long(ch) faire  Algorithme de la procédure
Ecrire(sous-chaine(ch,1,i)) Afficher
Fin Pour 0) DEF PROC AFFICHER(CH: chaine de
i : compteur caractères)
Fin Afficher 1) Pour i de 1 à long(ch) faire
T.D.O Locaux Ecrire(sous-chaine(ch,1,i))
Objet T/N Rôle Fin Pour
i Entier Compteur 2) Fin Afficher

 Traduction Pascal
PROGRAM chaine ; PROCEDURE Saisie(VAR ch :string) ;

88 Bac Scientifique Idoudi Khaled Enseignant :

USES wincrt ; BEGIN
VAR Ch :string ; REPEAT
PROCEDURE Afficher(ch :string) ; Write('Donner une chaine: ');
VAR i :integer ; Readln(ch) ;
BEGIN UNTIL length(ch)>=3 ;
for i:=1 to length(ch) do END;
writeln(copy(ch,1,i)) ; BEGIN
END ; Saisie(ch) ;
Afficher(ch) ;
END.

Exercice 24
 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var ch) FN MajusMinus(ch)

 Analyse
FN Alphabetique de programme principal :
(ch)
Nom de programme : chaine
Résultat:
 Algorithme de programme principal:
0) Début chaine
écrire("Chaine résultat : ",Res)
1) PROC Saisie(ch)
Res Fn MajusMinus(ch)
2) Res Fn MajusMinus(ch)
PROC Saisie(ch)
3) écrire("Chaine résultat : ",Res)
Fin chaine
T.D.O Globaux 4) Fin chaine
Objet T/N Rôle
Ch Chaine de caractère stocker une chaine de caractère
Saisie Procédure Saisir une chaine de caractère
MajusMinus Fonction Réorganiser les lettres d’une chaine donnée

 Analyse de la procédure Saisie

 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères)
Saisie
Résultat : ch
ch=[]Répéter 0) DEF PROC SAISIE(VAR ch:chaine
ch=donnée("Donner une chaine : ") de caractères)
1) Répéter
écrire("Donner une chaine : ")
89 Bac Scientifique lire(ch)Idoudi Khaled Enseignant :
jusqu’à (long(ch) dans [1..50])
et (FN Alphabetique(ch))
2) Fin Saisie
jusqu’à (long(ch) dans [1..50]) et
(FN Alphabetique(ch))
Fin Saisie

T.D.O Locaux
Objet T/N Rôle
Alphabetique Fonction Tester si une chaine est composée seulement par des
lettres alphabétiques ou non
 Analyse de la fonction Alphabétique
DEF FN ALPHABETIQUE(CH :chaine de caractères) :BOOLEEN
Résultat : Alphabétiquetest
Test=[testvrai,i1]  Algorithme de la fonction
Répéter Alphabétique
Si Non(Majus(Ch[i])dans["A".."Z"])
0) DEF FN ALPHABETIQUE(CH :chaine de
Alors
Test faux caractères) :BOOLEEN
Fin Si 1) Répéter
ii+1 Si Non(Majus(Ch[i])dans["A".."Z"])
jusqu’à (test=faux) ou (i>long(ch)) Alors
Fin Alphabétique Test faux
T.D.O Locaux Fin Si
ii+1
Objet T/N Rôle
jusqu’à (test=faux) ou
I Entier Compteur (i>long(ch))
test booléen Tester si la chaine 2) Alphabétiquetest
est composée 3) Fin Alphabétique
seulement par des
lettres alphabétiques
 Analyse de la fonction MajusMinus
DEF FN MAJUSMINUS(CH :chaine de caractères) : chaine de caractères
Résultat : MajusMinus CMajus+ VMajus+ CMinus+ VMinus
[Vmajus"", Vminus"", Cmajus"", Cminus""]
pour i de 1 à long(ch) faire
Selon ch[i] faire
"A","E","I","O","U","Y" : VMajus VMajus+ ch[i]
"a","e","i","o","u","y" : VMinus VMinus+ ch[i]
"A".."Z" : CMajus CMajus+ ch[i]
"a".."z" : CMinus CMinus+ ch[i]
Fin Selon
Fin Pour  Algorithme de la fonction MajusMinus
i :compteur 0) DEF FN MAJUSMINUS (CH :chaine de caractères) : chaine
Fin MajusMinus 1) [Vmajus"", Vminus"", Cmajus"", Cminus""]
pour i de 1 à long(ch) faire
Selon ch[i] faire
"A","E","I","O","U","Y" : VMajus VMajus+ ch[i]
"a","e","i","o","u","y" : VMinus VMinus+ ch[i]
90 Bac Scientifique Idoudi Khaled Enseignant :
"A".."Z" : CMajus CMajus+ ch[i]
"a".."z" : CMinus CMinus+ ch[i]
Fin Selon
Fin Pour
 T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
VMajus chaine Contient les lettres voyelles Majuscules
VMinus chaine Contient les lettres voyelles Minuscules
CMajus chaine Contient les lettres consonnes Majuscules
CMinus chaine Contient les lettres consonnes Minuscules
 Traduction Pascal
PROGRAM chaine ; FUNCTION MajusMinus(ch:string) :String;
USES wincrt ; VAR i :integer ;
VAR Ch,res :string ; Vmajus, Vminus, Cmajus, Cminus:string ;
PROCEDURE Saisie(VAR ch :string) ; BEGIN
FUNCTION Alphabetique(ch :string):Boolean; Vmajus:='' ; Vminus:='' ; Cmajus:='' ;
VAR Cminus:='' ;
i :integer ; test :boolean ; For i :=1 to length(ch) do
BEGIN Case ch[i] of
Test :=true ; i :=1 ;
'A', 'E', 'I', 'O', 'U', 'Y' :
Repeat
If NOT(Upcase(Ch[i])in['A'..'Z']) VMajus:= VMajus+ ch[i];
then 'a', 'e', 'i', 'o', 'u', 'y' :
Test :=false ; VMinus:= VMinus+ ch[i];
i :=i+1 ; 'A'.. 'Z' : CMajus:= CMajus+ ch[i];
Until (test=false)OR(i>length(ch)) ; 'a'.. 'z' : CMinus:= CMinus+ ch[i];
Alphabetique :=test ; END;
END ; MajusMinus := CMajus+ VMajus+ CMinus+
BEGIN VMinus;
REPEAT END ;
Write('Donner une chaine: '); BEGIN
Readln(ch) ; Saisie(ch) ;
UNTIL (length(ch)in [1..50]) AND Res := MajusMinus(ch);
(Alphabetique(ch)) ; write('Chaine résultat : ',Res)
END;
END.

91 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 25

 Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N) PROC Afficher(N,T)
Remplir( N,var T) PROC Inverser(N,var T)
PROC Permuter(var x,y)

 Analyse de programme principal :

Nom de programme : Inverser_Tableau

 Algorithme de programme
principal:
Résultat : PROC Afficher(n,T)
0) Début Inverser_Tableau
PROC Inverser(n,T)
1) PROC Saisie(n)
PROC Remplir(n,T) 2) PROC Remplir(n,T)
PROC Saisie(n) 3) PROC Inverser(n,T)
Fin Inverser_Tableau 4) PROC Afficher(n,T)
5) Fin Inverser_Tableau
T.D.N.T
Type
TAB= Tableau de taille 20 et de type caractère
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
T TAB Remplir le tableau par N caractères
Afficher Procédure Afficher un tableau
Remplir Procédure Remplir le tableau par n caractères.
Saisie Procédure Saisir la taille du tableau
Inverser Procédure Inverser les éléments d’un tableau T
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR N:entier)  Algorithme de la procédure

Résultat : n Saisie
n=[]Répéter 0) DEF PROC SAISIE(VAR n :entier)
n=donnée("Donner la taille de tableau: ") 1) Répéter
jusqu’à n dans [3..20] écrire("Donner la taille du
Fin Saisie tableau: ")
lire(n)
jusqu’à n dans [3..20]
2) Fin Saisie

 Analyse de la procédure Remplir

92 Bac Scientifique Idoudi Khaled Enseignant :

DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
T[i]=donnée("T[",i, "]=") 0) DEF PROC REMPLIR(N :ENTIER ;VAR T: TAB)
Fin Pour
1) Pour i de 1 à N faire
i : compteur
écrire("T[",i, "]=")
Fin Remplir
lire(T[i])
T.D.O Locaux
Fin Pour
Objet T/N Rôle 2) Fin Remplir
I Entier Compteur

Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER ;T :TAB)
Résultat : Trait  Algorithme de la procédure Afficher
Trait=[]Pour i de 1 à N faire 0) DEF PROC AFFICHER(N :ENTIER ;T:TAB)
Ecrire("T[",i, "]=",T[i]) 1) Pour i de 1 à N faire
Fin Pour Ecrire("T[",i, "]=",T[i])
i : compteur Fin Pour
Fin Afficher 2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur

Analyse de la procédure Inverser
DEF PROC INVERSER(N:ENTIER; VAR T:TAB)
Résultat : T
Pour i de 1 à N div 2 faire
 Algorithme de la procédure Inverser
PROC Permuter(T[i],T[n-i+1]) 0) DEF PROC INVERSER(N:ENTIER; VAR T:TAB)
Fin Pour 1) Pour i de 1 à N div 2 faire
i : compteur PROC Permuter(T[i],T[n-i+1])
Fin Inverser Fin Pour
T.D.O Locaux 2) Fin Inverser
Objet T/N Rôle
I Entier Compteur
Permuter Procédure Permuter deux caractères

Analyse de la procédure Permuter
DEF PROC Permuter(VAR x,y :caractère)
Résultat : x,y  Algorithme de la procédure
Auxx Permuter
Xy 0) DEF PROC Permuter(VAR x,y :caractère)
Yaux 1) Auxx
Fin Permuter 2) Xy
3) Yaux
T.D.O Locaux
Objet T/N Rôle
Aux caractère Variable auxiliaire

93 Bac Scientifique Idoudi Khaled Enseignant :

  Traduction Pascal
PROGRAM Inverser_tableau; PROCEDURE Inverser(n:integer;var T:TAB);
USES wincrt ; VAR
TYPE TAB= array[1..20] of char ; i:integer ;
VAR n :integer ; PROCEDURE Permuter(var x,y :char);
T :TAB ; VAR
PROCEDURE Saisie(VAR n :integer) ; aux :char ;
BEGIN BEGIN
Aux :=x ;
Repeat x :=y ;
Write('Donner la taille du tableau:'); y :=aux ;
Readln(n) ; END ;
until n in [3..20] ; BEGIN
END; for i :=1 to n div 2 do
Permuter(T[i], T[n-i+1]) ;
PROCEDURE Remplir(n:integer;VAR T:TAB);
END;
VAR i :integer ;
BEGIN
BEGIN
for i :=1 to n do Saisie(n);
begin Remplir(n,T);
Write('T[',i, ']= ') ; Inverser(n,T);
Readln(T[i] ) ; Afficher(n,T) ;
end ; END.
END;
PROCEDURE Afficher(n:integer;T:TAB) ;
VAR i :integer ;
BEGIN
for i :=1 to n do
Write(T[i],' ') ;
END;

94 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 26

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var X) PROC PROC Afficher(T)

Construire(X,var T)

FN Nombre(c,u,d) FN MIN(T) FN Max(T)

 Analyse de programme principal :

Nom de programme : ConstruireNombres

 Algorithme de programme
principal:
Résultat : PROC Afficher(T)
0) Début ConstruireNombres
PROC Construire(X,T)
1) PROC Saisie(x)
PROC Saisie(X) 2) PROC Construire(x,T)
Fin ConstruireNombres 3) PROC Afficher(T)
4) Fin ConstruireNombres
T.D.N.T
Type
TAB= Tableau de taille 6 et de type entiers
T.D.O Globaux
Objet T/N Rôle
X Entier stocker un entier de 3 chiffres
T TAB Remplir le tableau par 6
Afficher Procédure Afficher un tableau
Remplir le tableau par 6 entiers de 3 chiffres qui
Construire Procédure
compose le nombre X
Saisie Procédure Saisir le nombre X
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR X:entier)

Résultat : x  Algorithme de la procédure Saisie
x=[]Répéter 0) DEF PROC SAISIE(VAR x :entier)
x=donnée("Donner un entier: ") 1) Répéter
jusqu’à (x ≥ 100) et (x≤999) écrire("Donner entier: ")
Fin Saisie lire(x)
jusqu’à (x ≥ 100) et (x≤999)
2) Fin Saisie

95 Bac Scientifique Idoudi Khaled Enseignant :

  Analyse de la procédure Construire
DEF PROC CONSTRUIRE(X :ENTIER ;VAR T :TAB)
Résultat : T
T[1] FN Nombre(c,u,d)  Algorithme de la procédure Construire
T[2] FN Nombre(c,d,u) 0) DEF PROC CONSTRUIRE(X :ENTIER;VAR T:TAB)
T[3] FN Nombre(d,u,c) 1) CX div 100
T[4] FN Nombre(d,c,u) 2) D(X mod 100) div 10
T[5] FN Nombre(u,c,d) 3) UX mod 10
T[6] FN Nombre(u,d,c) 4) T[1] FN Nombre(c,u,d)
CX div 100 5) T[2] FN Nombre(c,d,u)
D(X mod 100) div 10 6) T[3] FN Nombre(d,u,c)
UX mod 10 7) T[4] FN Nombre(d,c,u)
Fin Construire 8) T[5] FN Nombre(u,c,d)
9) T[6] FN Nombre(u,d,c)
10) Fin Construire
T.D.O Locaux
Objet T/N Rôle
c,u,d Entier Déterminer les chiffres d’un nombre
Nombre Fonction Construire un nombre de 3 chiffres
 Analyse de la Fonction Nombre
DEF FN Nombre(C,D,U:ENTIER) : ENTIER  Algorithme de la Fonction Nombre
Résultat : Nombre  c*100+d*10+u 0) DEF FN Nombre(C,D,U:ENTIER):ENTIER
Fin Nombre 1) Nombre  c*100+d*10+u
2) Fin Nombre

 Analyse de la procédure Afficher

DEF PROC AFFICHER(T :TAB)
Résultat : écrire("Max=", FN Max(T))  Algorithme de la procédure Afficher
écrire("Min=", FN Min(T)) 0) DEF PROC AFFICHER(T:TAB)
Pour i de 1 à 6 faire 1) Pour i de 1 à 6 faire
Ecrire("T[",i, "]=",T[i]) Ecrire("T[",i, "]=",T[i])
Fin Pour Fin Pour
i : compteur 2) écrire("Max=", FN Max(T))
Fin Afficher 3) écrire("Min=", FN Min(T))
4) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Min Fonction Déterminer le minimum dans un tableau
Max Fonction Déterminer le maximum dans un tableau

 Analyse de la Fonction Max

 Algorithme de la Fonction Max
0) DEF FN Max(T:TAB) : ENTIER
96 Bac Scientifique Idoudi Khaled Enseignant :
1) [mT[1]]
2) Pour i de 1 à 6 faire
si(T[i]>m) alors
mT[i]
DEF FN Max(T :TAB) : ENTIER
Résultat : Max  m
m=[mT[1]]
Pour i de 1 à 6 faire
si(T[i]>m) alors
mT[i]
Fin Si
Fin pour
i:compteur
Fin Max
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
M Entier Déterminer la valeur maximale d’une liste des valeurs
 Analyse de la Fonction Min
DEF FN Min(T :TAB) : ENTIER
 Algorithme de la Fonction Min
0) DEF FN Min(T:TAB) : ENTIER
Résultat : Min  m
m=[mT[1]] 1) [mT[1]]
Pour i de 1 à n faire 2) Pour i de 1 à n faire
si(T[i]<m) alors si(T[i]<m) alors
mT[i] mT[i]
Fin Si Fin Si
Fin pour Fin pour
i:compteur 3) Min  m
Fin Min 4) Fin Min
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
M Entier Déterminer la valeur minimale d’une liste des valeurs

 Traduction Pascal
PROGRAM ConstruireNombres; PROCEDURE Afficher(T:TAB) ;
USES wincrt ; VAR i :integer ;
TYPE TAB= array[1..6] of integer ; FUNCTION Max(T:TAB): integer;
VAR X :integer ; VAR
T :TAB ; i,m :integer ;
PROCEDURE Saisie(VAR X :integer) ; BEGIN
m := T[1] ;
BEGIN
FOR i :=1 to 6 do
Repeat if(T[i]>m) then
Write('Donner un entier:'); m := T[i] ;
Readln(x) ; Max :=m ;
END;
until (x>=100) and (x<=999) ;
FUNCTION Min(T:TAB): integer;
END; VAR
PROCEDURE Construire(X:integer;VAR T:TAB); i,m :integer ;
VAR i,c,u,d :integer ; BEGIN

97 Bac Scientifique Idoudi Khaled Enseignant :

FUNCTION Nombre(c,u,d:integer): integer; m := T[1] ;
BEGIN FOR i :=1 to 6 do
Nombre:= c*100+d*10+u ; if(T[i]<m) then
END; m := T[i] ;
BEGIN Min :=m ;
C:=X div 100; END;
D:= (X mod 100) div 10; BEGIN
U:=X mod 10; for i :=1 to 6 do
T[1] := Nombre(c,u,d); Write(T[i],' ') ;
T[2] := Nombre(c,d,u); Writeln ;
T[3] := Nombre(d,u,c); Writeln ('Max=', Max(T));
T[4] := Nombre(d,c,u); Writeln ('Min=', Min(T));
T[5] := Nombre(u,c,d); END;
T[6] := Nombre(u,d,c); BEGIN
END; Saisie(x);
Construire(x,T);
Afficher(T) ;
END.

Exercice 27

 Décomposition modulaire du problème

Programme Principal

PROC FN Parfait(N) PROC Afficher(N, SD,ND)

Diviseur(N,var SD,ND)

 Analyse de programme principal :  Algorithme de programme

principal:
Nom de programme : Subline
0) Début Subline
Résultat : PROC Afficher(n,SD,NB)
1) Ecrire("Donner un entier :")
PROC Diviseurs(n,SD,NB)
2) Lire(N)
N=donnée("Donner un entier :")
3) PROC Diviseurs(N,SD,NB)
Fin Subline
4) PROC Afficher(N,SD,NB)
5) Fin Subline

T.D.O Globaux
Objet T/N Rôle

98 Bac Scientifique Idoudi Khaled Enseignant :

N Entier
Stocker la valeur de N
SD Entier
Calculer la somme des diviseurs de N
NB Entier
Calculer le nombre des diviseurs de N
Calculer la somme des diviseurs et le nombre des
Diviseurs Procédure
diviseurs de N
Afficher Procédure Afficher si le nombre N est Subline ou non
Analyse de la procédure Diviseurs
DEF PROC DIVISEURS(N :ENTIER ;VAR SD,NB :ENTIER)
Résultat : SD,NB
(SD,NB)=[SD0, NB0]  Algorithme de la procédure Diviseurs
Pour i de 1 à N faire 0) DEF PROC DIVISEURS (N:ENTIER;VAR SD,NB :ENTIER)
Si N mod i =0 alors 1) [SD0, NB0]
SDSD+i Pour i de 1 à N faire
NBNB+1 Si N mod i =0 alors
Fin Si SDSD+i
Fin Pour NBNB+1
i : compteur Fin Si
Fin Diviseurs Fin Pour
2) Fin Diviseurs
T.D.O Locaux

Objet T/N Rôle

i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N,SD,NB :ENTIER)
Résultat : Trait
 Algorithme de la procédure Afficher
Trait=[] Si (FN Parfait(SD)) et 0) DEF PROC AFFICHER(N,SD,NB :ENTIER)
(FN Parfait(NB)) alors 1) Si (FN Parfait(SD)) et
Ecrire(N," est subline") (FN Parfait(NB)) alors
Sinon Ecrire(N," est subline")
Ecrire(N," n’est subline") Sinon
Fin Si Ecrire(N," n’est subline")
Fin Afficher Fin Si
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
Parfait Fonction Tester si un entier est parfait ou non

Analyse de la Fonction Parfait

DEF FN Parfait(N:ENTIER) : BOOLEEN  Algorithme de la Fonction Parfait
0) DEF FN Parfait(N:ENTIER) : BOOLEEN
99 Bac Scientifique 1) [s1] Idoudi Khaled Enseignant :
2) Pour i de 2 à N div 2 faire
Si(N mod i = 0) alors
SS+i
Fin Si
Résultat : ParfaitS=N
Trait=[]
S=[s1]Pour i de 2 à N div 2 faire
Si(N mod i = 0) alors
SS+i
Fin Si
Fin Pour
i : compteur
Fin Parfait

T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
S Entier Calculer la somme des diviseurs de x
 Traduction Pascal
PROGRAM Subline ; PROCEDURE Afficher(N ,SD,NB :integer) ;
USES wincrt ; FUNCTION Parfait(N:integer):Boolean;
VAR VAR i,S :integer ;
n,SD, NB :integer ; BEGIN
PROCEDURE Diviseurs(X :integer; VAR S :=1; FOR i :=2 to N div 2 do
If(N mod i = 0) then
SD,NB :integer) ;
S :=S+i ;
VAR i :integer ;
Parfait := S=N ;
BEGIN END ;
SD :=0 ; NB :=0 ; BEGIN
For i:=1 to N do If(Parfait(SD)) and (Parfait(NB)) then
if N mod i =0 then Writeln(N,' est subline')
begin Else
SD:=SD+i; Writeln(N,' n''est pas subline');
NB:=NB+1; END;
End; BEGIN
END; Write('Donner un entier :') ;
Readln(N) ;
Diviseurs(N,SD,NB) ;
Afficher(N,SD,NB) ;
END.

Exercice 28

 Décomposition modulaire du problème

Programme Principal

100 Bac Scientifique Idoudi Khaled Enseignant :

FN Suite(Pn2,i) PROC Afficher

  Analyse de programme principal :
 Algorithme de programme
Nom de programme : SuitePn principal:
Résultat : PROC Afficher 0) Début SuitePn
Fin SuitePn 1) PROC Afficher
2) Fin SuitePn
T.D.O Globaux
Objet T/N Rôle
Afficher Procédure Afficher les termes successifs d’une suite
 Analyse de la procédure Afficher
DEF PROC AFFICHER  Algorithme de la procédure Diviseurs
Résultat :
0) DEF PROC AFFICHER
[Pn22,i3]
Répéter 1) [Pn22,i3]
Pn Fn Suite(Pn2,i) Répéter
Ecrire("P",i,"=",Pn) Pn Fn Suite(Pn2,i)
ii+2 Ecrire("P",i,"=",Pn)
Jusqu’à abs(Pn-Pn2) < 1/carré(100) ii+2
Fin Afficher Jusqu’à abs(Pn-Pn2) < 1/carré(100)
2) Fin AFFICHER
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Pn Réel Calculer le terme d’indice n
Pn2 Réel Calculer le terme d’indice n-2
Suite Fonction Calculer le terme i d’une suite
 Analyse de la Fonction Suite
DEF FN Suite(P:REEL;I:ENTIER):RÉEL
 Algorithme de la Fonction Suite
Résultat : SuiteP*(i-1)/i*(i+1)/i
0) DEF FN Suite(P:REEL;I:ENTIER):REEL
Fin Suite 1) Suite P*(i-1)/i*(i+1)/i
2) Fin Suite

 Traduction Pascal
PROGRAM SuitePn ; BEGIN
USES wincrt ; Afficher ;
PROCEDURE Afficher ; END.

101 Bac Scientifique Idoudi Khaled Enseignant :

 VAR i :integer ;
Pn,Pn2 :real ;
FUNCTION Suite(p :real ;i:integer):real;
BEGIN
Suite := P*(i-1)/i*(i+1)/i ;
END ;
BEGIN
Pn2:=2; i:=3;
Repeat
Pn:= Suite(Pn2,i);
writeln('P',i, '=',Pn) ;
i:=i+2;
Until abs(Pn-Pn2) < 1/sqr(100);
END;

Exercice 29

 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var N) PROC PROC RechercheNom ( Nom,N,Tnom)

PROC Tri_Nom(N, varPROC
Remplir_Contact(N, var TNom,Ttel) Tnom,Ttel)
Tri_Tel(N, var Tnom ,Ttel)

PROC RechercheTel
( numTel,N,Ttel)
Proc Proc
LireNom(var nom) LireTel(var tel) FN MINNom(N,Tnom)
FN MINTel(N,Ttel)

Proc PermuterNom(Var ch1,ch2)Proc PermuterTel ( Var n1,n2)

FN Majuscule(N,T) FN TelValide(Tel)

 Algorithme de programme
principal:
 Analyse de programme principal : 0) Début Annuaire
1) PROC Saisie(N)
Nom de programme : Annuaire 2) PROC Remplir_Contact(N,Tnom,
Résultat:PROC RechercheTel(numTel,N,Ttel) Ttel)
3) PROC Tri_Nom(N, Tnom, Ttel)
102 Bac Scientifique 4) PROC LireNom(Nom)
Idoudi Khaled Enseignant :
5) PROC RechercheNom(Nom,N,Tnom)
6) PROC Tri_Tel(N, Tnom, Ttel)
7) PROC LireTel(numTel)
 PROC LireTel(numTel)
PROC Tri_Tel(N,Tnom, Ttel)
PROC RechercheNom(Nom,N,Tnom)
PROC LireNom(Nom)
PROC Tri_Nom(N,Tnom, Ttel)
PROC Remplir_Contact(N,Tnom, Ttel)
PROC Saisie(N)
Fin Annuaire
T.D.N.T
Type
T_Nom = chaine de caractère de taille 20
T_Tel = chaine de caractère de taille 8
TABNom= Tableau de taille 50 et de type T_Nom
TABTel= Tableau de taille 50 et de type T_Tel
T.D.O Globaux
Objet T/N Rôle
N Entier stocker le nombre des contacts
Tnom TABNom Remplir le tableau par N noms
Ttel TABTel Remplir le tableau par N Numéros de téléphone
numTel T_Tel Stocker un numéro de téléphone
Nom T_Nom Stocker un nom d’une personne
Saisie Procédure Saisir le nombre des contacts
Remplir_Contact Procédure Remplir les deux tableaux Tnom et Ttel
Tri_Tel Procédure Trier le tableau Ttel
Tri_Nom Procédure Trier le tableau Tnom
LireNom Procédure saisir un nom de personne
LireTel Procédure saisir un numéro de téléphone
RechercheNom Procédure Vérifier l’existence d’un nom dans l’annuaire
Vérifier l’existence d’un numéro de téléphone
RechercheTel Procédure
dans l’annuaire
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR N:entier) Saisie
Résultat : N 0) DEF PROC SAISIE(VAR N :entier)
N=[]Répéter 1) Répéter
N=donnée("Donner le nombre de contact:") écrire("Donner le nombre de
jusqu’à (N ≥ 5) et (N≤50) contact: ")
Fin Saisie lire(N)
jusqu’à (N ≥ 5) et (N≤50)
 Analyse de la procédure LireNom2) Fin Saisie
DEF PROC LIRENOM(VAR NOM:T_Nom)  Algorithme de la procédure LireNom
Résultat : nom 0) DEF PROC LIRENOM(VAR NOM:T_Nom)
Nom=[]Répéter 1) Répéter
Nom=donnée("Nom: ") écrire("Nom: ")
lire(Nom)
103 Bac Scientifique jusqu’à FN Majuscule(Nom)
Idoudi Khaled Enseignant :
2) Fin LireNom
jusqu’à FN Majuscule(Nom)
Fin LireNom

T.D.O Locaux
Objet T/N Rôle
Majuscule Fonction Tester si la chaine est composée seulement par des
lettres majuscules ou non
 Analyse de la fonction Majuscule
DEF FN MAJUSCULE(CH:T_Nom):BOOLEEN
Résultat : Majusculetest  Algorithme de la fonction
Test=[testvrai,i1] Majuscule
Répéter 0) DEF FN MAJUSCULE(CH:T_Nom):
Si Non(Ch[i] dans["A".."Z"]) Alors BOOLEEN
Test faux 1) Répéter
Fin Si Si Non(Ch[i]dans["A".."Z"]) Alors
ii+1 Test faux
jusqu’à (test=faux) ou (i>long(ch)) Fin Si
Fin Majuscule ii+1
T.D.O Locaux jusqu’à (test=faux) ou
Objet T/N Rôle (i>long(ch))
I Entier Compteur 2) Majusculetest
3) Fin Majuscule
test booléen Tester si la chaine
est composée
seulement par des
lettres majuscules
 Analyse de la procédure LireTel

DEF PROC LIRETEL(VAR TEL:T_Tel)

Résultat : tel
 Algorithme de la procédure LireTel
tel =[]Répéter 0) DEF PROC LIRETEL(VAR TEL:T_tel)
tel =donnée("N° Tel: ") 1) Répéter
jusqu’à FN TelValide(tel) écrire("N° Tel ")
Fin LireTel lire(tel)
jusqu’à FN TelValide (tel)
2) Fin LireTel
T.D.O Locaux
Objet T/N Rôle
TelValide Fonction Tester si un n°Tel donné est valide ou non

 Analyse de la fonction TelValide

DEF FN TELVALIDE(TEL :T_TEL):BOOLEEN  Algorithme de la fonction
Résultat : TelValidetest TelValide
Si long(ch)≠8 alors
4) DEF FN TELVALIDE(TEL :ENTIER):
testfaux
Fin Si BOOLEEN
5) [testvrai,i1]
104 Bac Scientifique Répéter Idoudi Khaled Enseignant :
Si Non(tel[i] dans["0".."9"]) ou
Non(tel[1] dans
["2","4","5","7","9"])
Alors
Test=[testvrai,i1]
Répéter
Si Non(tel[i] dans["0".."9"]) ou
Non(tel[1] dans["2","4","5","7","9"])
Alors
Test faux
Fin Si
ii+1
jusqu’à (test=faux) ou (i>long(tel))
Fin TelValide
T.D.O Locaux
Objet T/N Rôle
I entier compteur
test booléen Tester si un numéro de
Tel est valide ou non
 Analyse de la procédure Remplir_Contact
DEF PROC REMPLIR_CONTACT(N :ENTIER ; VAR Tnom:TABNom;VAR T[Link]
Résultat : Tnom,Ttel
(Tnom,Ttel) =[]  Algorithme de la procédure Remplir_Contact
Pour i de 1 à N faire 0) DEF PROC REMPLIR_CONTACT(N :ENTIER ; VAR
PROC LireNom(Tnom[i]) Tnom:TABNom; VAR T[Link]
PROC LireTel(Ttel[i]) 1) Pour i de 1 à N faire
Fin Pour PROC LireNom(Tnom[i])
Fin Remplir_Contact PROC LireTel(Ttel[i])
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir_Contact
I Entier Compteur
 Analyse de la procédure Tri_Tel
DEF PROC TRI_TEL(N :ENTIER ; VAR Tnom:TABNom;VAR T[Link]
Résultat : Tnom,Ttel
Pour i de 1 à N-1 faire  Algorithme de la procédure Tri_Tel
posminFN MinTel(i,N,Ttel) 0) DEF PROC TRI_TEL(N :ENTIER ; VAR
si posmin ≠ i alors Tnom:TABNom;VAR T[Link]
PROC PermutTel(Ttel[posmin],Ttel[i]) 1) Pour i de 1 à N-1 faire
PROC PermutNom(Tnom[posmin],Tnom[i]) posminFN MinTel(i,N,Ttel)
Fin Si si posmin ≠ i alors
Fin Pour PROC PermutTel(Ttel[posmin],Ttel[i])
i : compteur PROC PermutNom(Tnom[posmin],Tnom[i])
Fin Tri_Tel Fin Si
T.D.O Locaux Fin Pour
Objet T/N 2) Fin Tri_Tel
Rôle
I Entier Compteur
MinTel Fonction Déterminer la position de plus petit numéro de
téléphone dans Ttel à partir d’une position pos
 Analyse de la Fonction MinTel

105 Bac Scientifique Idoudi Khaled Enseignant :

DEF FN Mintel(pos,n:ENTIER; T[Link]
Résultat : MinTel  posmin
posmin =[posminpos]  Algorithme de la Fonction MinTel
Pour i de pos+1 à n faire 0) DEF FN
si(Ttel[i]<Ttel[posmin]) alors Mintel(pos,n:ENTIER;T[Link] :
posmini
ENTIER
Fin Si
Fin pour 1) [posminpos]
i:compteur Pour i de pos+1 à n faire
Fin MinTel si(Ttel[i]<Ttel[posmin]) alors
posmini
Fin Si
Fin pour
T.D.O Locaux 2) MinTel  posmin
Objet T/N Rôle
I Entier Compteur
Posmin entier Déterminer la position de plus petit numéro de téléphone
dans Ttel à partir d’une position pos
 Analyse de la procédure PermutTel
DEF PROC PERMUTTEL(VAR X,Y :T_TEL)
Résultat : x,y  Algorithme de la procédure
auxx PermutTel
xy 0) DEF PROC PERMUTTEL(VAR X,Y : T_TEL)
yaux 1) Auxx
Fin PermutTel 2) Xy
T.D.O Locaux 3) Yaux
Objet T/N Rôle
aux T_Tel Variable auxiliaire
 Analyse de la procédure Tri_Nom
DEF PROC TRI_NOM(N :ENTIER ; VAR Tnom:TABNom;VAR T[Link]
Résultat : Tnom,Ttel
Pour i de 1 à N-1 faire
posminFN MinNom(i,N,TNom)
si posmin ≠ i alors
PROC PermutTel(Ttel[posmin],Ttel[i])
PROC PermutNom(Tnom[posmin],Tnom[i])
Fin Si  Algorithme de la procédure Tri_Nom
Fin Pour 0) DEF PROC TRI_NOM(N:ENTIER;VAR Tnom:TABNom;VAR T[Link]
i : compteur
1) Pour i de 1 à N-1 faire
Fin Tri_Nom
posminFN MinNom (i,N,TNom)
si posmin ≠ i alors
PROC PermutTel(Ttel[posmin],Ttel[i])
PROC PermutNom(Tnom[posmin],Tnom[i])
Fin Si
Fin Pour
2) Fin Tri_Nom

106 Bac Scientifique Idoudi Khaled Enseignant :

 T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
MinNom Fonction Déterminer la position de plus petit nom dans TNom à
partir d’une position pos
 Analyse de la Fonction MinNom
DEF FN MinNom(pos,n:ENTIER; T[Link]
Résultat : MinNom  posmin  Algorithme de la Fonction MinNom
posmin =[posminpos]
Pour i de pos+1 à n faire 0) DEF FN
si(TNom[i]<TNom[posmin]) alors MinNom(pos,n:ENTIER;T[Link] :
posmini ENTIER
Fin Si 1) [posminpos]
Fin pour Pour i de pos+1 à n faire
i:compteur si(TNom[i]<TNom[posmin]) alors
Fin MinNom posmini
Fin Si
Fin pour
2) MinNom  posmin
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
Posmin entier Déterminer la position de plus petit nom dans TNom à partir
d’une position pos
 Analyse de la procédure PermutNom
DEF PROC PERMUTNOM(VAR NOM1,NOM2 :T_NOM)
Résultat : nom1,nom2
auxnom1  Algorithme de la procédure PermutNom
nom1 nom2 0) DEF PROC PERMUTNOM(VAR NOM1,NOM2 : T_NOM)
nom2aux 1) auxnom1
Fin PermutNom 2) nom1 nom2
3) nom2aux
T.D.O Locaux 4) Fin PermutNom
Objet T/N Rôle
aux T_Nom Variable auxiliaire
 Analyse de la procédure RechercheNom

DEF PROC RECHERCHE_NOM(NOM :T_NOM ;N :ENTIER ; Tnom:TABNom)

Résultat : Trait
Trait=[]si (Nom=Tnom[m] ) alors
ecrire("Le nom existe dans l’annuaire")
Sinon
ecrire("Le nom n’existe pas dans l’annuaire")
Fin si
 Algorithme de la procédure RechercheNom
0) DEF PROC RECHERCHE_NOM(NOM:T_NOM;N:ENTIER;
107 Bac Scientifique Idoudi Khaled Enseignant :
Tnom:TABNom)
1) [g 1,d N] répéter
m (g+d) div2
Si Nom<Tnom[m] alors
[g 1,d N] répéter
m (g+d) div2
Si Nom<Tnom[m] alors
d m-1
Sinon
g m+1
Fin Si
jusqu’à (Nom=Tnom[m]) ou (g>d)
Fin RechercheNom

T.D.O Locaux
Objet T/N Rôle
g Entier Partie gauche
d Entier Partie droite
m Entier Milieu de
tableau

 Analyse de la procédure RechercheTel

DEF PROC RECHERCHE_TEL(NumTel :T_Tel ;N :ENTIER ; T[Link]

Résultat :Trait
Trait=[]si (numTel=Ttel[m] ) alors
ecrire("Le numéro de téléphone existe dans l’annuaire")
Sinon
ecrire("Le numéro de téléphone n’existe pas dans l’annuaire")
Fin si
[g 1,d N] répéter
m (g+d) div2
Si NumTel<Ttel[m] alors T.D.O Locaux
Objet T/N Rôle
d m-1 g Entier Partie gauche
Sinon
d Entier Partie droite
g m+1
m Entier Milieu de tableau
Fin Si
jusqu’à (NumTel=Ttel[m])ou(g>d)
Fin
 RechercheTel
Algorithme de la procédure RechercheTel
0) DEF PROC RECHERCHE_NOM(NumTel :T_Tel ;N:ENTIER; T[Link]
1) [g 1,d N] répéter
m (g+d) div2
Si NumTel<Ttel[m] alors
d m-1
Sinon
g m+1
Fin Si
jusqu’à (NumTel=Ttel [m]) ou (g>d)
2) si (NumTel=Ttel[m] ) alors
ecrire("Le numéro de téléphone existe dans l’annuaire")
Sinon
108 Bac Scientifique Idoudi Khaled Enseignant :
ecrire("Le numéro de téléphone n’existe pas dans l’annuaire")
Fin si
3) Fin RechercheNom
  Traduction Pascal
PROGRAM Annuaire; PROCEDURE Tri_Tel(n:integer ; VAR
USES wincrt ; Tnom:TABNom ; VAR T[Link] ;
TYPE VAR posmin,i :integer ;
T_Nom= string[20] ; FUNCTION MinTel(pos,n:integer;T:TABTel):integer;
T_Tel= string[8] ; VAR posmin,i :integer ;
TABTel=Array[1..50] of T_Tel; BEGIN
TABNom=Array[1..50] of T_Nom; posmin:=pos;
VAR for i := pos+1 to n do
if(T[i]<T[posmin]) then
N:integer ;
posmin:=i;
numTel :T_Tel; Nom :T_Nom ; MinTel := posmin;
Tnom :TABNom; T[Link] ; END;
PROCEDURE Saisie(VAR N :integer); BEGIN
BEGIN for i :=1 to n do
repeat begin
Write('Donner le nombre de contact: Posmin := MinTel(i,N,Ttel) ;
'); if posmin <> i then
Readln(N) ; begin
until(N>=5)and(N<=50); PermutTel(Ttel[posmin],Ttel[i]) ;
END; PermutNom(Tnom[posmin],Tnom[i]) ;
PROCEDURE LireNom(VAR Nom :T_Nom); end;
FUNCTION Majuscule(ch :T_Nom):Boolean; end;
VAR i:integer; test:boolean ; END;
BEGIN PROCEDURE Tri_Nom(n:integer ; VAR
Test :=true ; i :=1 ;
Tnom:TABNom ; VAR T[Link] ;
Repeat
If Not(Ch[i]in['A'.. 'Z']) then VAR posmin,i :integer ;
Test:= false; FUNCTION MinNom(pos,n:integer;T:TABNom):integer;
i:=i+1; VAR posmin,i :integer ;
until (test=false)or(i>length(ch)) ; BEGIN
Majuscule :=test ; posmin:=pos;
END; for i := pos+1 to n do
if(T[i]<T[posmin]) then
BEGIN
posmin:=i;
repeat
MinNom := posmin;
Write('Nom: '); END;
Readln(Nom) ; BEGIN
Until Majuscule(Nom); for i :=1 to n do
END; begin
PROCEDURE LireTel(VAR numtel :T_Tel); Posmin := MinNom(i,N,TNom) ;
FUNCTION TelValide([Link] if posmin <> i then
VAR i :integer; test:boolean ; begin
BEGIN
PermutTel(Ttel[posmin],Ttel[i]) ;
Test:=true;i:=1;
PermutNom(Tnom[posmin],Tnom[i]) ;

109 Bac Scientifique Idoudi Khaled Enseignant :

Repeat end;
if NOT(tel[i] in ['0'.. '9']) OR end;
NOT(tel[1] in ['2','4','5','7','9']) END;
then PROCEDURE RechercheNom(nom:T_Tel; VAR
Test:= false; n:integer ;VAR Tnom:TABNom);
i:=i+1;
VAR g,d,m :integer ;
until (test=false) or (i>length(tel));
if length(tel)<>8 then BEGIN
test:=false; g :=1;d:= N; Repeat
TelValide :=test ; m:= (g+d) div 2;
END; if Nom<Tnom[m] then
BEGIN d := m-1
repeat else
Write('N°Tel: '); g:= m+1;
Readln(numtel) ; until (Nom=Tnom[m]) or (g>d);
Until TelValide(numtel); if (Nom=Tnom[m] ) then
END; writeln('Le nom existe dans l''annuaire')
PROCEDURE Remplir_Contact(n:integer; else
VAR Tnom:TABNom ; VAR T[Link] writeln('Le nom n''existe pas dans
VAR i :integer ; l''annuaire');
BEGIN END;
for i :=1 to n do PROCEDURE RechercheTel(numTel:T_Nom; VAR
begin n:integer ;VAR T[Link]
writeln('==> Contact n°',i) ; VAR g,d,m :integer ;
LireNom(Tnom[i]); BEGIN
LireTel(Ttel[i]); g :=1;d:= N; Repeat
end; m:= (g+d) div 2;
END; if numTel<Ttel[m] then
PROCEDURE PermutTel(VAR x,y:T_Tel); d := m-1
VAR aux : T_Tel ; else
BEGIN g:= m+1;
aux :=x ; until (numTel=Ttel[m]) or (g>d);
x :=y ; if (numTel = Ttel [m] ) then
y :=aux ; writeln('Le numéro de téléphone existe dans
END; l''annuaire')
PROCEDURE PermutNom(VAR nom1,nom2: else
T_Nom); writeln('Le numéro de téléphone n''existe
VAR aux : T_Nom; pas dans l''annuaire');
BEGIN END;
aux :=nom1 ;
nom1 := nom2 ; BEGIN
nom2 :=aux ; Saisie(N);
END; Remplir_Contact(N,Tnom, Ttel);
Writeln('== Recherche d'un nom ==');
Tri_Nom(N, Tnom, Ttel);
LireNom(Nom);
RechercheNom(Nom,N,Tnom);
Writeln('== Recherche d'un N°Tel==');
Tri_Tel(N, Tnom, Ttel);

110 Bac Scientifique Idoudi Khaled Enseignant :

 LireTel(numTel);
RechercheTel(numTel,N,Ttel);
END.

Exercice 30

 Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N,b_inf,b_sup)
Remplir(N,var T) PROC AfficherDiviseurs(b_inf,b_sup,p,T)
PROC AfficherMultiples(b_inf,b_sup,p,T)

 Analyse de programme principal :

Nom de programme : DiviseurMultiple

Résultat: PROC AfficherMultiples(b_inf,b_sup,p,T)
PROC AfficherDiviseurs(b_inf,b_sup,p,T)
P=donnée("Donner un entier :")
PROC Remplir(N,T)  Algorithme de programme
PROC Saisie(N, b_inf,b_sup) principal:
Fin DiviseurMultiple 0) Début DiviseurMultiple
1) PROC Saisie(N, b_inf,b_sup)
T.D.N.T 2) PROC Remplir(N,T)
Type 3) Ecrire("Donner un entier")
TAB= Tableau de taille 15 et de type entier 4) Lire(p)
5) PROC AfficherDiviseurs
(b_inf,b_sup,p,T)
6) PROC AfficherMultiples
(b_inf,b_sup,p,T)
T.D.O Globaux 7) Fin DiviseurMultiple
Objet T/N Rôle
N Entier Stocker la taille de tableau
b_inf,b_sup Entier Stocker deux positions dans le tableau
T TAB Remplir un tableau par N entiers
P Entier Saisir la valeur de p
Remplir Procédure Remplir un tableau par N entiers
Saisie Procédure Saisir les valeurs de N, b_inf et b_sup
AfficherDiviseurs Procédure Afficher les diviseurs de p dans le tableau

111 Bac Scientifique Idoudi Khaled Enseignant :

 compris entre b_inf et b_sup
Afficher les multiples de p dans le tableau
AfficherMultiples Procédure
compris entre b_inf et b_sup
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR N,B_INF,B_SUP:ENTIER) Saisie
Résultat : N,b_inf,b_sup 0) DEF PROC SAISIE(VAR N, B_INF,
(N,b_inf,b_sup)=[]Répéter B_SUP :ENTIER)
N=donnée("Donner la taille de tableau:")
1) Répéter
B_inf=donnée("B_inf= ")
B_Sup=donnée("B_Sup= ") écrire("Donner la taille de
jusqu’à (b_inf≥1)ET(b_sup≤N) ET tableau : ") lire(N)
(b_inf≤b_sup)ET(N≤15) écrire("B_inf = ") lire(B_inf)
Fin Saisie écrire("B_Sup = ") lire(B_Sup)
jusqu’à (b_inf≥1)ET(b_sup≤N) ET
(b_inf≤b_sup)ET(N≤15)
2) Fin Saisie

 Analyse de la procédure Remplir

DEF PROC REMPLIR(N :ENTIER ; VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR(N :ENTIER ; VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
jusqu’à T[i]≥0 Répéter
Fin Pour écrire("T[",i, "]=")
i : compteur lire(T[i])
Fin Remplir jusqu’à T[i]≥0
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur

 Analyse de la procédure AfficherDiviseurs

DEF PROC AFFICHERDIVISEURS(B_INF,B_SUP,P :ENTIER ;T :TAB)
Résultat : Trait
Trait=[]
 Algorithme de la procédure
Pour i de b_inf à b_sup faire AfficherDiviseurs
Si p mod T[i] = 0 alors 0) DEF PROC AFFICHERDIVISEURS(B_INF,B_SUP,
Ecrire(T[i] ," ") P :ENTIER ; T:TAB)
Fin Si 1) Pour i de b_inf à b_sup faire
Fin Pour Si p mod T[i] = 0 alors
i : compteur Ecrire(T[i] ," ")
Fin Si
112 Bac Scientifique Fin Pour Idoudi Khaled Enseignant :
2) Fin AfficherDiviseurs
 Fin AfficherDiviseurs

T.D.O Locaux
Objet T/N Rôle
i Entier Compteur

Analyse de la procédure AfficherMultiples
DEF PROC AFFICHERMULTIPLES(B_INF,B_SUP,P :ENTIER ;T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]
AfficherMultiples
Pour i de b_inf à b_sup faire
Si T[i] mod p = 0 alors 0) DEF PROC AFFICHERMULTIPLES(B_INF,B_SUP,
Ecrire(T[i]," ") P :ENTIER ; T:TAB)
Fin Si 1) Pour i de b_inf à b_sup faire
Fin Pour Si T[i] mod p = 0 alors
i : compteur Ecrire(T[i] ," ")
Fin AfficherMultiples Fin Si
Fin Pour
T.D.O Locaux 2) Fin AfficherMultiples
Objet T/N Rôle
i Entier Compteur
 Traduction Pascal

PROGRAM DiviseurMultiple; PROCEDURE Remplir(N :integer ;VAR

USES wincrt ; T:TAB);
TYPE TAB=Array[1..15] of integer ; VAR i :integer ;
VAR BEGIN
N,p,b_inf,b_sup:integer ; for i :=1 to N do
T :TAB ; repeat
PROCEDURE Saisie(VAR Write('T[',i, ']= ') ;
N,b_inf,b_sup :integer) ; Readln(T[i]) ;
BEGIN until T[i]>=0 ;
repeat END;
Write('Donner la taille de PROCEDURE AfficherDiviseurs
tableau :'); Readln(N) ; (b_inf,b_sup,p :integer ; VAR T:TAB);
Write('b_inf= '); Readln(b_inf) ; VAR i :integer ;
Write('b_sup= '); Readln(b_sup) ; BEGIN
Until (b_inf>=1) and (b_sup<=N) and for i :=b_inf to b_sup do
(b_inf <= b_sup) and (n<=15); if p mod T[i] = 0 then
END; Write(T[i], ' ') ;
PROCEDURE AfficherMultiples END;
(b_inf,b_sup,p :integer ; VAR T:TAB); BEGIN
VAR i :integer ; Saisie(N,b_inf,b_sup) ;
BEGIN Remplir(N,T);
for i := b_inf to b_sup do Write('Donner la valeur de P :') ;
if T[i] mod p = 0 then
Readln(P) ;
Write(T[i], ' ') ;

113 Bac Scientifique Idoudi Khaled Enseignant :

END; AfficherDiviseurs(b_inf,b_sup,p,T) ;
AfficherMultiples(b_inf,b_sup,p,T) ;
END.

Exercice 31

 Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N)
Remplir(N,var T) PROC SuppOccurrence(N,T) FN NbElement(N,T)

 Analyse de programme principal :

Nom de programme : ElementDistinct

 Algorithme de programme
principal:
Résultat: écrire("Le tableau contient ",
0) Début ElementDistinct
FN NbElement(N,T), "
1) PROC Saisie(N)
éléments distinct")
2) PROC Remplir(N,T)
PROC SuppOccurrence(N,T)
3) PROC SuppOccurrence(N,T)
PROC Remplir(N,T)
4) écrire("Le tableau contient ",FN
PROC Saisie(N)
NbElement(N,T)," éléments
Fin ElementDistinct
distinct")
5) Fin ElementDistinct
T.D.N.T
Type
TAB= Tableau de taille 20 et de type entier
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la taille de tableau
T TAB Remplir un tableau par N entiers
P Entier Saisir la valeur de p
Remplir Procédure Remplir un tableau par N entiers

114 Bac Scientifique Idoudi Khaled Enseignant :

 Saisie Procédure Saisir les valeurs de N, b_inf et b_sup
NbElement Fonction Calculer le nombre d’éléments distinct de T
SuppOccurrence Procédure Remplacer les éléments qui se répètent par 0
 Analyse de la procédure Saisie
 Algorithme de la procédure
DEF PROC SAISIE(VAR N:ENTIER) Saisie
Résultat : N
0) DEF PROC SAISIE(VAR N:ENTIER)
N=[]Répéter
N=donnée("Donner la taille de tableau:") 1) Répéter
jusqu’à (2≤N) ET (N≤20) écrire("Donner la taille de
Fin Saisie tableau : ") lire(N)
jusqu’à (2≤N) ET (N≤20)
 Analyse de la procédure Remplir2) Fin Saisie
DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR(N :ENTIER ;VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
jusqu’à T[i]>0 Répéter
Fin Pour écrire("T[",i, "]=")
i : compteur lire(T[i])
Fin Remplir jusqu’à T[i]>0
Fin Pour
T.D.O Locaux 2) Fin Remplir
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure SuppOccurrence
DEF PROC SUPPOCCURRENCE(N :ENTIER ; VAR T :TAB)
Résultat : T
Pour i de 1 à N-1 faire
 Algorithme de la procédure SuppOccurrence
Si T[i] > 0 alors 0) DEF PROC SUPPOCCURRENCE (N:ENTIER;VAR T:TAB)
Pour j de i+1 à N faire 1) Pour i de 1 à N-1 faire
Si T[i]=T[j] alors Si T[i] > 0 alors
T[j]0 Pour j de i+1 à N faire
Fin Si Si T[i]=T[j] alors
Fin Pour T[j]0
Fin Si Fin Si
Fin Pour Fin Pour
i,j : compteur Fin Si
Fin SuppOccurrence Fin Pour
T.D.O Locaux 2) Fin SuppOccurrence
Objet T/N Rôle
i,j Entier Compteur
Analyse de la fonction NbElement
DEF FN NBELEMENT(N :ENTIER ;T :TAB) :ENTIER

115 Bac Scientifique Idoudi Khaled Enseignant :

Résultat : NbElementNb
Nb=[Nb0]  Algorithme de la procédure NbElement
Pour i de 1 à N faire 0) DEF FN NBELEMENT (N:ENTIER; T:TAB) :ENTIER
Si T[i] > 0 alors 1) [Nb0]Pour i de 1 à N faire
NbNb+1 Si T[i] > 0 alors
Fin Si NbNb+1
Fin Pour Fin Si
i : compteur Fin Pour
Fin NbElement 2) NbElementNb
3) Fin NbElement
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
NB Entier Calculer le nombre d’éléments distinct de T
 Traduction Pascal

PROGRAM ElementDistinct; PROCEDURE Remplir(N:integer; VAR T:TAB);

USES wincrt ; VAR i :integer ;
TYPE TAB=Array[1..20] of integer ; BEGIN
VAR for i :=1 to N do
N:integer ; repeat
T :TAB ; Write('T[',i, ']= ') ;
PROCEDURE Saisie(VAR N:integer) ; Readln(T[i]) ;
BEGIN until T[i]>0 ;
repeat END;
Write('Donner la taille de FUNCTION NbElement(N:integer;VAR
tableau :'); Readln(N) ; T:TAB) :integer;
Until (2<=N) and (n<=20); VAR i,NB :integer ;
END; BEGIN
PROCEDURE SuppOccurrence (N:integer ; Nb :=0 ;
VAR T:TAB); for i :=1 to N do
VAR i,j :integer ; if T[i] > 0 then
BEGIN Nb:=Nb+1;
for i := 1 to N-1 do NbElement :=Nb ;
if T[i] > 0 then END;
for j :=i+1 to N do BEGIN
if T[i]=T[j] then Saisie(N) ;
T[j]:=0; Remplir(N,T);
END; SuppOccurrence(N,T);
writeln('Le tableau contient ',
NbElement(N,T),' éléments distinct')
END.

Exercice 32

116 Bac Scientifique Idoudi Khaled Enseignant :

  Décomposition modulaire du problème

Programme Principal

PROC PROC
PROC Saisie(var N) PROC Tri(N,var T) PROC Recherche(prenom,N,T)
Remplir(N,var T) Majuscule(N,var T)

PROC
SuppPrénom (L1,L2,N,var T)
FN MIN(p,N, T) PROC Permut(ch1,ch2)

Algorithme de programme
principal:
 Analyse de programme principal: 0) Début Exercice32
1) PROC Saisie(N)
Nom de programme : Exercice32 2) PROC Remplir(N,T)
Résultat:PROC Recherche (prenom,N,T) 3) PROC Majuscule (N, T)
prenom=donnée("Donner le prénom cherché:") 4) PROC Tri(N,T)
PROC SuppPrénom(L1,L2,N,T) 5) Ecrire("Donner un L1 :")
L1=donnée("Donner un L1 :") 6) Lire(L1)
L2=donnée("Donner un L2 :") 7) Ecrire("Donner un L2 :")
PROC Tri(N,T) 8) Lire(L2)
PROC Majuscule(N,T) 9) PROC SuppPrénom(L1,L2,N,T)
PROC Remplir (N,T) 10) Ecrire("Donner le prénom
PROC Saisie(N) cherché:")
Fin Exercice32 11) Lire(prenom)
12) PROC Recherche(prenom,N,Ttel)
T.D.N.T
Type
TAB= Tableau de taille 100 et de type chaine de caractères
T.D.O Globaux
Objet T/N Rôle
N Entier stocker le nombre des contacts
T TAB Remplir le tableau par N noms
L1, L2 caractère Saisir deux caractères
Prénom chaine Stocker un prénom d’une personne
Saisie Procédure Saisir la taille de tableau
Remplir Procédure Remplir le tableau T par N prénoms
Tri Procédure Trier le tableau T
Majuscule Procédure Convertir tous les prénoms en majuscule
SuppPrénom Procédure Supprimer tous les prénoms dont le caractère

117 Bac Scientifique Idoudi Khaled Enseignant :

 n°1 est compris entre L1 et L2
Vérifier l’existence d’un prénom dans le
Recherche Procédure
tableau
 Analyse de la procédure Saisie

Algorithme de la procédure
DEF PROC SAISIE(VAR N:entier) Saisie
Résultat : N 0) DEF PROC SAISIE(VAR N :entier)
N=[]Répéter 1) Répéter
N=donnée("Donner la taille de tableau:") écrire("Donner le nombre de
jusqu’à (N ≥ 10) et (N<100) contact: ")
Fin Saisie lire(N)
jusqu’à (N ≥ 10) et (N<100)
2) Fin Saisie

 Analyse de la procédure Remplir

DEF PROC REMPLIR (N:ENTIER; VAR T:TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR (N:ENTIER; VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
jusqu’à long(T[i])≠0 Répéter
Fin Pour écrire("T[",i, "]=")
Fin Remplir lire(T[i])
T.D.O Locaux jusqu’à long(T[i])≠0
Objet T/N Rôle Fin Pour
2) Fin Remplir
I Entier Compteur
 Analyse de la procédure Majuscule
DEF PROC MAJUSCULE(N:ENTIER; VAR T:TAB)
Résultat : T
Pour i de 1 à N faire  Algorithme de la procédure Majuscule
ChT[i]
0) DEF PROC MAJUSCULE(N:ENTIER;VAR T:TAB)
Pour j de 1 à long(ch) faire
ch[j]Majus(ch[j]) 1) Pour i de 1 à N faire
Fin Pour ChT[i]
T[i] Ch Pour j de 1 à long(ch) faire
Fin Pour ch[j]Majus(ch[j])
Fin Majuscule Fin Pour
T.D.O Locaux T[i] Ch
Fin Pour
Objet T/N Rôle 2) Fin Majuscule
i,j Entier Compteur
ch chaine Chaine auxiliaire
 Analyse de la procédure Tri
DEF PROC TRI(N:ENTIER; VAR T:TAB)
 Algorithme de la procédure Tri
0) DEF PROC TRI (N :ENTIER ; VAR T:TAB)
118 Bac Scientifique 1) Pour i de 1 à N-1 faire
Idoudi Khaled Enseignant :
posminFN Min(i,N,T)
si posmin ≠ i alors
PROC Permut(T[posmin],T[i])
Résultat : T
Pour i de 1 à N-1 faire
posminFN Min (i,N,T)
si posmin ≠ i alors
PROC Permut(T[posmin],T[i])
Fin Si
Fin Pour
i : compteur
Fin Tri

T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
Min Fonction Déterminer la position de plus petit prénom dans T à
partir d’une position pos
 Analyse de la Fonction Min
DEF FN Min (pos,n:ENTIER; T:TAB):ENTIER
Résultat : Min  posmin
posmin =[posminpos]  Algorithme de la Fonction Min
Pour i de pos+1 à n faire 0) DEF FN Min(pos,n:ENTIER;T:TAB):ENTIER
si(T[i]<T [posmin]) alors 1) [posminpos]
posmini Pour i de pos+1 à n faire
Fin Si si(T[i]<T[posmin]) alors
Fin pour posmini
i:compteur Fin Si
Fin Min Fin pour
2) Min posmin
3) Fin Min
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
posmin entier Déterminer la position de plus petit prénom dans le
tableau T à partir d’une position pos
 Analyse de la procédure Permut
DEF PROC PERMUT (VAR CH1,CH2:CHAINE)
Résultat : ch1,ch2  Algorithme de la procédure Permut
aux ch1 0) DEF PROC PERMUTTEL(VAR CH1,CH2:CHAINE)
ch1 ch2 1) aux ch1
ch2aux 2) ch1 ch2
Fin Permut 3) ch2aux
T.D.O Locaux 4) Fin Permut
Objet T/N Rôle
aux chaine Variable auxiliaire
 Analyse de la procédure SuppPrenom

119 Bac Scientifique Idoudi Khaled Enseignant :

DEF PROC SUPPPRENOM(L1,L2 :CARACTERE ;N :ENTIER ; VAR T :TAB)
Résultat : T
Pour i de 1 à N faire  Algorithme de la procédure
ChT[i] SuppPrenom
Si ch[1] dans[L1..L2] alors 0) DEF PROC SUPPPRENOM (L1,L2:CARACTERE;
T[i]"" N:ENTIER;VAR T:TAB)
Fin Si 1) Pour i de 1 à N faire
Fin Pour ChT[i]
i: compteur Si ch[1] dans[L1..L2] alors
Fin SuppPrenom T[i]""
T.D.O Locaux Fin Si
Objet T/N Rôle Fin Pour
i Entier Compteur 2) Fin SuppPrenom
Ch Chaine Chaine
auxiliaire
Analyse de la procédure Décaler
DEF PROC DECALER(N :ENTIER ; VAR T :TAB)
Résultat : T
Pour i de 1 à N faire  Algorithme de la procédure Décaler
Si T[i]= "" alors 0) DEF PROC DECALER(N:ENTIER; VAR T :TAB)
T[i]"" 1) Pour i de 1 à N faire
[J0]Répéter Si T[i]= "" alors
Jj+1 T[i]""
Jusqu’à (T[j]≠ "")ou(j=N) [J0]Répéter
PROC Permuter(T[i], T[j]) Jj+1
Fin Si Jusqu’à (T[j]≠ "")ou(j=N)
Fin Pour PROC Permuter(T[i], T[j])
i: compteur Fin Si
Fin Décaler Fin Pour
T.D.O Locaux 2) Fin Décaler
Objet T/N Rôle
i,j Entier Compteur
 Analyse de la procédure Recherche

DEF PROC RECHERCHE(PRENOM :chaine ;N :ENTIER ; T:TAB)

Résultat :Trait
Trait=[]si (prenom=T[i] ) alors  Algorithme de la procédure Recherche
ecrire("existe ") 0) DEF PROC RECHERCHE(N:ENTIER;VAR T:TAB)
Sinon 1) [i0] répéter
ecrire("n’existe pas ") ii+1
Fin si jusqu’à (prenom=T[i])ou(i=N)
[i0] répéter 2) si (prenom=T[i] ) alors
ii+1 ecrire("existe ")
jusqu’à (prenom=T[i])ou(i=N) Sinon
Fin Recherche ecrire("n’existe pas ")
T.D.O Locaux Fin si
3) Fin Recherche
120 Bac Scientifique Idoudi Khaled Enseignant :
 Objet T/N Rôle
i Entier Compteur
 Traduction Pascal

PROGRAM Exercice32; PROCEDURE Tri(n:integer ; VAR T:TAB) ;

USES wincrt ; VAR posmin,i :integer ;
TYPE FUNCTION Min(pos,n:integer;T:TAB):integer;
TAB=Array[1..100] of string; VAR posmin,i :integer ;
VAR BEGIN
L1,L2 :char ; posmin:=pos;
N:integer ; for i := pos+1 to n do
if(T[i]<T[posmin]) then
prenom :string ;
posmin:=i;
T :TAB ; Min := posmin;
END;
BEGIN
PROCEDURE Saisie(VAR N :integer); for i :=1 to n do
BEGIN begin
repeat Posmin := Min(i,N,T) ;
Write('Donner la taille de tableau:'); if posmin <> i then
Readln(N) ; Permuter(T[posmin],T[i]) ;
until(N>=10)and(N<100); end;
END; END;
PROCEDURE Remplir(n:integer;VAR PROCEDURE Decaler(N :integer; VAR T:TAB);
T:TAB); VAR i,j :integer ;
VAR i :integer ; BEGIN
BEGIN for i :=1 to n do
for i :=1 to n do if T[i]='' then
begin begin
repeat j:=0;
Write('T[',i,']= '); Repeat
Readln(T[i]) ; J:=j+1;
Until length(T[i])<>0 ; Until (T[j]<> '')or(j=N);
end; Permuter(T[i], T[j]);
END; End;
PROCEDURE Majuscule(N :integer ; VAR END;
T:TAB); PROCEDURE Recherche (prenom:string; VAR
VAR i,j:integer; ch :string ; n:integer; VAR T:TAB);
BEGIN VAR i :integer ;
for i :=1 to n do BEGIN
Ch:=T[i]; i:=0; Repeat
for j :=1 to length(ch) do i:= i+1;
ch[j]:=Upcase(ch[j]); until (prenom=T[i]) or (i=n);
END; if (prenom=T[i] ) then
PROCEDURE Permuter(VAR nom1,nom2: writeln(' existe')
string); else
VAR aux : string; writeln('n''existe pas');
BEGIN END;
aux :=nom1 ;

121 Bac Scientifique Idoudi Khaled Enseignant :

 nom1 := nom2 ; BEGIN
nom2 :=aux ; Saisie(N);
END; Remplir(N,T);
PROCEDURE SuppPrenom(L1,L2:char; Majuscule(N,T);
N :integer; VAR T:TAB); Tri(N,T);
VAR i,j:integer; ch :string ;
Write('Donner L1:');
BEGIN
for i :=1 to n do Readln(L1);
Ch:=T[i]; Write('Donner L2:');
if ch[1] in [L1..L2] then Readln(L2);
T[i]:= ''; SuppPrenom(L1,L2,N,T);
END; Decaler(N,T);
Write('Donner un prènom:');
Readln(prenom);
Exercice 33
Recherche (prenom,N,T);
END.

 Décomposition modulaire du problème

Programme Principal

PROC
PROC
PROC Saisie(var N,P) RemplirT(N,var T) PROC Vérifier(P,Tm,N,T)
RemplirTm(P,var Tm)

 Analyse de programme principal:  Algorithme de programme

principal:
Nom de programme : Existance
0) Début Existance
Résultat:PROC Vérifier (P,Tm,N,T)
1) PROC Saisie(N,P)
PROC RemplirT (N,T)
2) PROC RemplirTm(p,Tm)
PROC RemplirTm (P,Tm)
3) PROC RemplirT(N,T)
PROC Saisie(N,P)
4) PROC Vérifier(P,Tm,N,T)
Fin Existance
T.D.N.T
Type
TABmot= Tableau de taille 20 et de type chaine de caractères
TAB= Tableau de taille 200 et de type caractère
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille de tableau T
T TAB Remplir le tableau par N caractères
P Entier stocker la taille de tableau Tm

122 Bac Scientifique Idoudi Khaled Enseignant :

 Remplir le tableau par p mot
Tm TABmot
Saisie Procédure Saisir les tailles de tableau
RemplirT Procédure Remplir le tableau T
RemplirTm Procédure Remplir le tableau Tm
Vérifier l’existence des mots du tableau Tm
Verifier Procédure
dans le tableau T.
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR N,P:entier)

Résultat : N,P
(N,P)=[]Répéter
N=donnée("Donner la taille de tableau T:")
P=donnée("Donner la taille de tableau Tm:")
jusqu’à (N dans
[3..199]) et (P
Algorithme de dans [3..19]) Saisie
la procédure
Fin Saisie
0) DEF PROC SAISIE(VAR N,P :entier)
1) Répéter
écrire("Donner la taille de tableau T: ")
lire(N)
écrire("Donner la taille de tableau Tm: ")
lire(p)
jusqu’à (N dans [3..199]) et (P dans [3..19])
2) Fin Saisie
 Analyse de la procédure RemplirT
DEF PROC REMPLIRT (N:ENTIER; VAR T:TAB)
Résultat : T
T =[]Pour i de 1 à N faire
T[i]=donnée("T[",i, "]=")
 Algorithme de la procédure RemplirT
Fin Pour 0) DEF PROC REMPLIRT (N:ENTIER; VAR T:TAB)
Fin RemplirT 1) Pour i de 1 à N faire
T.D.O Locaux écrire("T[",i, "]=")
lire(T[i])
Objet T/N Rôle
Fin Pour
I Entier Compteur 2) Fin RemplirT

 Analyse de la procédure RemplirTm

DEF PROC REMPLIRTM P:ENTIER; VAR TM:TABmot)
Résultat : T
T =[]Pour i de 1 à p faire  Algorithme de la procédure RemplirTm
Répéter 0) DEF PROC REMPLIRTM (P:ENTIER;VAR TM:TABmot)
Tm[i]=donnée("Tm[",i, "]=") 1) Pour i de 1 à P faire
jusqu’à long(Tm[i])≠0 Répéter
Fin Pour écrire("Tm[",i, "]=")
Fin RemplirTm lire(Tm[i])
T.D.O Locaux jusqu’à long(Tm[i])≠0
Objet T/N Rôle Fin Pour
2) Fin RemplirTm

123 Bac Scientifique Idoudi Khaled Enseignant :

i Entier Compteur
 Analyse de la procédure Vérifier
DEF PROC VERIFIER(P:ENTIER; TM:TABmot ;N:ENTIER; VAR T:TAB)
Résultat : T
T =[]
Pour i de 1 à p faire
ChTm[i]
[j1]
Répéter
[ch1"", k1]
Si ch[1] = T[j] alors
[lj]Répéter
Si ch[k]=T[l] alors
Ch1ch1+T[l]
Kk+1
Fin Si
ll+1
jusqu’à (l-j+1>long(ch)) ou (l>N)
Fin Si
Jj+1 T.D.O Locaux
jusqu’à (ch=ch1)ou(j>N)
si ch=ch1 alors écrire(ch,"==> Objet T/N Rôle
existe") i,j,k,l Entier Compteurs
sinon écrire(ch,"==> n’existe Ch,ch1 chaine Chaine auxiliaires
pas")
Fin Si  Algorithme de la procédure Vérifier
Fin Pour 0) DEF PROC VERIFIER(P:ENTIER; TM:TABmot; N:ENTIER; VAR T:TAB)
Fin Vérifier 1) Pour i de 1 à p faire
ChTm[i]
[j1]
Répéter
[ch1"", k1]
Si ch[1] = T[j] alors
[lj]Répéter
Si ch[k]=T[l] alors
Ch1ch1+T[l]
Kk+1
Fin Si
ll+1
jusqu’à (l-j+1>long(ch))ou(l>N)
Fin Si
Jj+1
jusqu’à (ch=ch1)ou(j>N)
si ch=ch1 alors écrire(ch,"==> existe")
sinon écrire(ch,"==> n’existe pas")
Fin Si
Fin Pour
2) Fin Vérifier

124 Bac Scientifique Idoudi Khaled Enseignant :

  Traduction Pascal
PROGRAM Existance; PROCEDURE verifier(p:integer; Tm:TABmot;
USES wincrt ; n:integer ;T:TAB) ;
TYPE VAR i,j,k,l :integer ;
TAB=Array[1..200] of char; Ch,ch1 :string ;
TABmot=Array[1..20] of string; BEGIN
VAR for i :=1 to p do
N,p:integer ; begin
T :TAB ;Tm : TABmot ; Ch:=Tm[i] ;
PROCEDURE Saisie(VAR N,p :integer); j:=1;
BEGIN Repeat
repeat ch1:=''; k:=1;
Write('Donner la taille de tableau if ch[1] = T[j] then
T:'); begin
Readln(N) ; l:=j;
Write('Donner la taille de tableau Repeat
Tm:'); if ch[k]=T[l] then
Readln(P) ; begin
until(N in [3..199]) and (P in[3..19]) Ch1:=ch1+T[l];
END; K:=k+1;
PROCEDURE RemplirTm(p:integer;VAR End;
T:TABmot); l:=l+1;
VAR i :integer ; until (l-j+1>length(ch))or(l>N);
BEGIN End;
for i :=1 to p do J:=j+1;
begin until (ch=ch1)or(j>N);
repeat if ch=ch1 then write(ch,'==> existe')
Write('Tm[',i,']= '); else write (ch,'==> n''existe pas');
Readln(Tm[i]) ; end;
Until length(Tm[i])<>0 ; END;
end; BEGIN
END; Saisie(N,P);
PROCEDURE RemplirT(n:integer;VAR RemplirT(N,T);
T:TAB); RemplirTm(P,Tm);
VAR i :integer ; verifier (P,Tm,N,T);
BEGIN
for i :=1 to n do END.
begin
Write('T[',i,']= ');
Readln(T[i]) ;
end;
END;

Exercice 34

 Décomposition modulaire du problème

125 Bac Scientifique Programme Principal Idoudi Khaled Enseignant :

  Analyse de programme principal :

Nom de programme : Ecart

Résultat: PROC MinEcart(N,T)  Algorithme de programme
PROC Remplir(N,T) principal:
PROC Saisie(N) 0) Début Ecart
Fin Ecart 1) PROC Saisie(N)
T.D.N.T 2) PROC Remplir(N,T)
Type 3) PROC MinEcart(N,T)
TAB= Tableau de taille 20 et de type entier 4) Fin Ecart
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la taille de tableau
T TAB Remplir un tableau par N entiers
Remplir Procédure Remplir un tableau par N entiers
Saisie Procédure Saisir les valeurs de N
Afficher l’indice de l’élément du tableau dont l’écart
entre la somme (s1) des éléments qui le précédent et
MinEcart Procédure
celle des éléments qui le succèdent (s2) soit minimal.

 Analyse de la procédure Saisie


Algorithme de la procédure
DEF PROC SAISIE(VAR N:ENTIER) Saisie
Résultat : N 0) DEF PROC SAISIE(VAR N:ENTIER)
N=[]Répéter 1) Répéter
N=donnée("Donner la taille de tableau:")
écrire("Donner la taille de
jusqu’à (5≤N) ET (N≤20)
tableau : ") lire(N)
Fin Saisie
jusqu’à (5≤N) ET (N≤20)
2) Fin Saisie

126 Bac Scientifique Idoudi Khaled Enseignant :

 Analyse de la procédure Remplir
DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR(N :ENTIER ;VAR T:TAB)
T[i]random(100) 1) Pour i de 1 à N faire
jusqu’à T[i]>0 Répéter
Fin Pour T[i] random(100)
i : compteur jusqu’à T[i]>0
Fin Remplir Fin Pour
T.D.O Locaux 2) Fin Remplir
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure MinEcart
DEF PROC MINECART(N :ENTIER ;T :TAB)
Résultat: écrire("S1=",FN Somme(1,i-1),"S2=",FN Somme(i+1,N),"
ind=",ind)
[eabs(s1-s2),ind2]
Pour i de 3 à N-1 faire  Algorithme de la procédure MinEcart
S1FN Somme(1,i-1) 0) DEF PROC MINECART(N :ENTIER; T :TAB)
S2FN Somme(i+1,N) 1) S1FN Somme(T,1,1)
Si e < abs(S1-S2) alors 2) S2FN Somme(T,3,N)
eS1-S2 3) [eabs(s1-s2),ind2]
indi 4) Pour i de 3 à N-1 faire
Fin Si S1FN Somme(T,1,i-1)
Fin Pour S2FN Somme(T,i+1,N)
S1FN Somme(1,1) Si e > abs(S1-S2) alors
S2FN Somme(3,N) eabs(S1-S2)
i : compteur indi
Fin MinEcart Fin Si
Fin Pour
5) écrire("S1=",FN Somme(T,1,ind-1),"S2=",FN
Somme(T,ind+1,N)," ind=",ind)
6) Fin MinEcart
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
S1,S2 Entier Stocker les sommes des deux parties du tableau
E Entier Calculer l’écart entre S1 et S2
Ind Entier Déterminer l’indice dont l’écart entre les deux sommes
est minimal
Somme Fonction Calculer la somme des éléments d’un tableau entre deux
positions
 Analyse de la fonction somme

127 Bac Scientifique Idoudi Khaled Enseignant :

DEF FN SOMME(T :TAB ; P1,P2 :ENTIER) :ENTIER
Résultat : Sommes
S=[s0]Pour i de p1 à p2 faire
Ss+T[i]
 Algorithme de la procédure somme
Fin Pour 0) DEF FN SOMME(T:TAB ; P1,P2:ENTIER):ENTIER
i : compteur 1) [s0]
Fin somme Pour i de p1 à p2 faire
Ss+T[i]
Fin Pour
2) Sommes
T.D.O Locaux 3) Fin somme
Objet T/N Rôle
I Entier Compteur
S Entier Somme des éléments d’un tableau compris entre les
positions p1 et p2
Traduction Pascal
PROGRAM Ecart; PROCEDURE Saisie(VAR N:integer) ;
USES wincrt ; BEGIN
TYPE TAB=Array[1..20] of integer ; repeat
VAR N:integer ; Write('Donner la taille de
T :TAB ; tableau :'); Readln(N) ;
PROCEDURE MinEcart (N:integer ; VAR T:TAB); Until (5<=N) and (n<=20);
VAR i,s1,s2,e,ind :integer ; END;
FUNCTION PROCEDURE Remplir(N :integer; VAR
Somme(T:TAB;p1,p2:integer) :integer; T:TAB);
VAR i,s:integer ; VAR i :integer ;
BEGIN
BEGIN
S :=0 ;
for i:=p1 to p2 do Randomize ;
S :=s+T[i] ; for i :=1 to N do
Somme :=s ; repeat
END ; T[i] :=random(100) ;
BEGIN until T[i]>0 ;
S1 := Somme(T,1,1) ; END;
S2 := Somme(T,3,N) ; BEGIN
e:=abs(s1-s2) ;ind:=2 ; Saisie(N) ;
for i := 3 to n-1 do Remplir(N,T);
begin MinEcart(N,T) ;
S1:= Somme(T,1,i-1); END.
S2:= Somme(T,i+1,N);
if e > abs(S1-S2) then
begin
e:=abs(S1-S2);
ind:=i;
end;
end;
write('S1= ',Somme(T,1,ind-1),' S2= ',
Somme(T,ind+1,N),' ind=',ind);

128 Bac Scientifique Idoudi Khaled Enseignant :

Exercice 35
END;

 Décomposition modulaire du problème

Programme Principal

PROC Remplir (n, var T) PROC Afficher (n, R)

PROC Saisie(var n) PROC Crypter (n,T, var R)

FN Permuter (code)

Analyse de programme principal :  Algorithme de programme

Nom de programme : Cryptage principal:
Résultat: PROC Afficher(n, R) 0) Début Cryptage
PROC crypter (n,T,R) 1) PROC Saisie(n)
PROC Remplir (n,T) 2) PROC Remplir (n,T)
PROC Saisie(n) 3) PROC Crypter (n,T,R)
Fin Cryptage 4) PROC Afficher(n,R)
5) Fin Cryptage
T.D.N.T
Type
TAB= Tableau de taille 100 et de type de caractère
T.D.O Globaux
Objet T/N Rôle
N Entier Stocker la taille de tableau
T TAB Stocker le tableau T par n caractères
R TAB Contient le résultat de cryptage du tableau T
Saisie Procédure Saisir la taille de tableau
Remplir Procédure Remplir un tableau par n caractères
Crypter le tableau T et affecter le résultat au
Crypter Procédure
tableau R
Afficher Procédure Afficher les éléments d’un tableau
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR N:entier)  Algorithme de la procédure

Résultat : n Saisie
n=[]Répéter 0) DEF PROC SAISIE(VAR n :entier)
n=donnée("Donner la taille de tableau: ") 1) Répéter
jusqu’à n dans [3..20] écrire("Donner la taille du
tableau: ")
129 Bac Scientifique lire(n) Idoudi Khaled Enseignant :
jusqu’à n dans [3..20]
2) Fin Saisie
Fin Saisie


Analyse de la procédure Remplir
DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T=[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
répéter 0) DEF PROC REMPLIR(N :ENTIER ;VAR T: TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
Jusqu’à majus(T[i]) dans ["A".."Z"] répéter
Fin Pour T[i]=donnée("T[",i, "]=")
i : compteur Jusqu’à majus(T[i]) dans ["A".."Z"]
Fin Remplir Fin Pour
2) Fin Remplir
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur

Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER ;R :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à N faire Afficher
Ecrire("R[",i, "]=",R[i]) 0) DEF PROC AFFICHER(N :ENTIER ;R:TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur Ecrire("R[",i, "]=",R[i])
Fin Afficher Fin Pour
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur

Analyse de la procédure Crypter
DEF PROC CRYPTER(N:ENTIER; T:TAB; VAR R:TAB )
Résultat : R
Pour i de 1 à N faire  Algorithme de la procédure Crypter
code ORD(T[i]) 0) DEF PROC CRYPTER(N:ENTIER; T:TAB; VAR R:TAB)
NcodeFN Permuter(code) 1) Pour i de 1 à N faire
R[i]CHR(Ncode) codeORD(T[i])
Fin Pour NcodeFN Permuter(code)
i : compteur R[i]CHR(Ncode)
Fin Crypter Fin Pour
2) Fin Crypter
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Code Entier Code ascii d’un caractère

130 Bac Scientifique Idoudi Khaled Enseignant :

 Ncode Entier Nouveau code ascii après permutation des chiffres
Permuter Fonction Permuter les deux chiffres de code ascii Code
 Analyse de la Fonction Permuter
DEF FN Permuter(code :entier):ENTIER
 Algorithme de la Fonction Permuter
Résultat : Permuter  u*10+d
dcode div 10 0) DEF FN Permuter(code :entier): ENTIER
ucode mod 10 1) dcode div 10
Fin Permuter 2) ucode mod 10
T.D.O Locaux 3) Permuter  u*10+d
4) Fin Permuter
Objet T/N Rôle
D entier Déterminer le chiffre de dizaine
U entier Déterminer le chiffre d’unité
 Traduction Pascal
PROGRAM Cryptage; PROCEDURE Crypter(n:integer; T:TAB ;
USES wincrt ; var R :TAB);
TYPE TAB= array[1..100] of char ; VAR
VAR n :integer ; i,code,Ncode :integer ;
T,R :TAB ; FUNCTION Permuter(code :integer):integer;
PROCEDURE Saisie(VAR n :integer) ; VAR
BEGIN d,u :integer ;
BEGIN
Repeat
D :=code div 10 ;
Write('Donner la taille du tableau:'); U :=code mod 10 ;
Readln(n) ; Permuter := u*10+d;
until n in [3..20] ; END ;
END; BEGIN
for i :=1 to n do
PROCEDURE Remplir(n:integer;VAR T:TAB);
begin
VAR i :integer ;
code :=ORD(T[i]) ;
BEGIN
Ncode := Permuter(code) ;
for i :=1 to n do
R[i]:= CHR(Ncode) ;
repeat
end;
Write('T[',i, ']= ') ;
END;
Readln(T[i] ) ;
BEGIN
until upcase(T[i]) in ['A'..'Z'];
END; Saisie(n);
PROCEDURE Afficher(n:integer;R:TAB) ; Remplir(n,T);
VAR i :integer ; Crypter(n,T,R);
BEGIN Afficher(n,R) ;
for i :=1 to n do END.
Writeln(' R[', i ,']=',R[i]) ;
END;

Exercice 36

131 Bac Scientifique Idoudi Khaled Enseignant :

  Décomposition modulaire du problème

Programme Principal

PROC
PROC Dessiner (L,C, symbole,choix)
Saisie(var L,C,symbole, choix)

 Analyse de programme principal:

Nom de programme : Rectangle
Résultat:  Algorithme de programme
PROC Dessiner(L,C,symbole,choix) principal:
PROC Saisie(L,C, symbole,choix) 0) Début Rectangle
Fin Rectangle 1) PROC Saisie(L,C,caractere,choix)
2) PROC Dessiner(L,C,caractere,choix)
T.D.O Globaux
Objet T/N Rôle
L,C entier Stocker les dimensions du rectangle à dessiner
symbole caractère Saisir un caractère parmi (x,+,$,*)
choix caractère Saisir le choix de dessin : soit plein (P) ou vide (V)
Saisir les paramètres nécessaires pour dessiner un
Saisie Procédure
rectangle
 Analyse de la procédure Saisie
DEF PROC SAISIE(VAR L,C:entier ; VAR SYMBOLE,CHOIX:caractére)
Résultat : L,C,symbole,choix
(L,C,symbole,choix)=[]
Répéter
L=donnée("Donner le nombre de ligne:")
C=donnée("Donner le nombre de colonne:")
jusqu’à (L≠C) et (L dans [2..10])
et (C dans [2..10])
symbole=[]Répéter
symbole=donnée("Donner le symbole de dessin (x,+,$,*): ")
jusqu’à symbole dans ["x","+","$","*"]
choix=[]Répéter
choix=donnée("Donner le choix de dessin (P ou V): ")
jusqu’à Majus(choix) dans ["P","V"]
Fin Saisie
 Algorithme de la procédure Saisie
0) DEF PROC SAISIE(VAR L,C:entier; VAR SYMBOLE,CHOIX: caractére)
1) Répéter
écrire("Donner le nombre de ligne:")
132 Bac Scientifique Lire(L) Idoudi Khaled Enseignant :
écrire ("Donner le nombre de colonne:")
Lire(C)
jusqu’à (L≠C) et (L dans [2..10]) et (C dans [2..10])
2) Répéter
  Analyse de la procédure Dessiner
DEF PROC DESSINER(L,C:entier; SYMBOLE,CHOIX: caractére)
Résultat : Trait
Trait=[]
Pour i de 1 à L faire
Pour j de 1 à C faire
Si Majus(choix)="P" alors
Ecrire(symbole)
Sinon
Si (i=1)ou(i=L)ou(j=1) ou(j=C) alors T.D.O Locaux
Ecrire(symbole)
Sinon Objet T/N Rôle
Ecrire(" ") i,j Entier Compteurs
Fin Si
Fin Si
Fin Pour
Ecrire() {écrire un retour à la ligne}
Fin Pour
i,j : compteur  Algorithme de la procédure Afficher
Fin Afficher 0) DEF DESSINER(L,C:entier; SYMBOLE,CHOIX: caractére)
1) Pour i de 1 à L faire
Pour j de 1 à C faire
Si Majus(choix)="P" alors
Ecrire(symbole)
Sinon
Si (i=1)ou(i=L)ou(j=1)ou(j=C) alors
Ecrire(symbole)
Sinon
Ecrire(" ")
Fin Si
Fin Si
Fin Pour
Ecrire()
Fin Pour
2) Fin Afficher
133 Bac Scientifique Idoudi Khaled Enseignant :
  Traduction Pascal
PROGRAM Rectangle ;
USES wincrt ;
VAR L,C :integer ;
Choix ,symbole:char ;
PROCEDURE Saisie(VAR l,c:integer; VAR symbole,choix: char) ;
BEGIN
REPEAT
Write('Donner le nombre de ligne:');
Readln(L) ;
Write(Donner le nombre de colonne:');
Readln(L) ;
UNTIL (L<>C) and (L in [2..10]) and (C in [2..10]);
REPEAT
Write('Donner le symbole de dessin (x,+,$,*):');
Readln(symbole) ;
UNTIL symbole dans ['x','+','$','*'];
REPEAT
Write('Donner le choix de dessin (P ou V): ');
Readln(choix) ;
UNTIL Upcase(choix) in ['P','V'];
END;
PROCEDURE Dessiner(l,c:integer; symbole,choix: char) ;
VAR i,j :integer ;
BEGIN
for i:=1 to L do
begin
for j:=1 to C do
begin
if(upcase(choix) = 'P') then
write(symbole)
else
begin
if(i=1)or(i=L)or(J=1)or(j=C) then
write(symbole)
else
write(' ') ;
end;
end; writeln;
end;
END ;
BEGIN
Saisie(L,C,symbole,choix) ;
Dessiner(L,C,symbole,choix) ;

134 Bac Scientifique Idoudi Khaled Enseignant :

END.
Exercice 37

 Décomposition modulaire du problème

Programme Principal

PROC
PROC Saisie(var N,D) PROC Afficher(N,T)
PROC Tri_bloc(p1,p2,var T)PROC Trier(N,D,var T)
Remplir( N,var T)

FN Min(p,p2,T) PROC Permut(var c1,c2)

 Analyse de programme principal :

 Algorithme de programme
Nom de programme : Tri_par_bloc principal:
Résultat : PROC Afficher(n,T) 0) Début Tri_par_bloc
PROC Trier(n,T) 1) PROC Saisie(n)
PROC Remplir(n,T) 2) PROC Remplir(n,T)
3) PROC Trier(n,T)
PROC Saisie(n)
4) PROC Afficher(n,T)
Fin Tri_par_bloc
5) Fin Tri_par_bloc
T.D.N.T
Type
TAB= Tableau de taille 100 et de type caractère
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille du tableau
D Entier stocker la taille du bloc
T TAB Remplir le tableau par N caractères
Afficher Procédure Afficher un tableau
Remplir Procédure Remplir le tableau par n caractères.
Saisie Procédure Saisir la taille du tableau
Trier Procédure Trier le tableau T dans l’ordre croissant par bloc
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR N,D :ENTIER)

Algorithme de la procédure Saisie
Résultat : N,D 0) DEF PROC SAISIE(VAR N,D :ENTIER)
(N,D)=[]Répéter 1) Répéter
N=donnée("Donner la valeur de N : ") écrire("Donner la valeur de N: ")
D=donnée("Donner la valeur de D : ") lire(N)
jusqu’à (N≥6)ET(N≤100)et écrire("Donner la valeur de D: ")
(N mod D=0)et(D>1) lire(D)
jusqu’à (N≥6)ET(N≤100)et(N mod D=0)
et(D>1)
135 Bac Scientifique 2) Fin Saisie Idoudi Khaled Enseignant :
Fin Saisie

Analyse de la procédure Remplir

DEF PROC REMPLIR(N :ENTIER ;VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR(N :ENTIER ;VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
jusqu’à T[i] dans ["a".."z"] Répéter
Fin Pour écrire("T[",i, "]=")
i : compteur lire(T[i])
Fin Remplir jusqu’à T[i] dans ["a".."z"]
T.D.O Locaux Fin Pour
Objet T/N Rôle 2) Fin Remplir
i Entier Compteur
Analyse de la procédure Afficher
DEF PROC AFFICHER(N :ENTIER ;T :TAB)
Résultat : Trait  Algorithme de la procédure
Trait=[]Pour i de 1 à N faire Afficher
Ecrire("T[",i, "]=",T[i]) 0) DEF PROC AFFICHER(N:ENTIER ;T :TAB)
Fin Pour 1) Pour i de 1 à N faire
i : compteur Ecrire("T[",i, "]=",T[i])
Fin Afficher Fin Pour
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Analyse de la procédure Trier
DEF PROC TRIER(N,D :ENTIER ;VAR T :TAB)
Résultat : T
T =[]Pour i de 1 à N div D faire
P1(i-1)*D+1
 Algorithme de la procédure Trier
P2i*D 0) DEF PROC TRIER(N,D:ENTIER ;VAR T:TAB)
Tri_bloc(p1,p2,T) 1) Pour i de 1 à N div D faire
Fin Pour P1(i-1)*D+1
i : compteur P2i*D
Fin Trier Tri_bloc(p1,p2,T)
Fin Pour
2) Fin Trier
T.D.O Locaux
Objet T/N Rôle
P1,p2 Entier Les bornes de chaque bloc du tableau de taille D
i Entier compteur
Tri_bloc Procédure Trier un bloc de taille D du tableau T

136 Bac Scientifique Idoudi Khaled Enseignant :

  Analyse de la procédure Tri_bloc
DEF PROC TRI_BLOC(P1,P2 :ENTIER ;VAR T :TAB)
Résultat : T  Algorithme de la procédure Tri_bloc
T =[]Pour i de p1 à p2-1 faire
0) DEF PROC TRI_BLOC(P1,P2:ENTIER;VAR
posminFN Min(i,p2,T)
si posmin ≠ i alors T:TAB)
PROC Permut(T[posmin],T[i]) 1) Pour i de p1 à p2-1 faire
Fin Si posminFN Min(i,p2,T)
Fin Pour si posmin ≠ i alors
i : compteur PROC Permut(T[posmin],T[i])
Fin Tri_bloc Fin Si
Fin Pour
T.D.O Locaux 2) Fin Tri_bloc
Objet T/N Rôle
i Entier Compteur
Min Fonction Déterminer la position de minimum dans un bloc
d’éléments d’un tableau à partir d’une position pos
Permut Procédure Permuter deux entiers dans un tableau
 Analyse de la Fonction Min
DEF FN Min(pos,p2:ENTIER;T:TAB):ENTIER
Résultat : Min  posmin  Algorithme de la Fonction Min
posmin =[posminpos]
Pour i de pos+1 à p2 faire 0) DEF FN Min(pos,n:ENTIER ;T:TAB): ENTIER
si(T[i]<T[posmin]) alors 1) [posminpos]
posmini Pour i de pos+1 à p2 faire
Fin Si si(T[i]<T[posmin]) alors
Fin pour posmini
i:compteur Fin Si
Fin Min Fin pour
2) Min  posmin
T.D.O Locaux 3) Fin Min
Objet T/N Rôle
I Entier Compteur
posmin entier Déterminer la position de minimum dans un tableau à partir
d’une position pos
 Analyse de la procédure Permut
DEF PROC PERMUT(VAR C1,C2 :CARACTÈRE)
Résultat : c1,c2  Algorithme de la procédure Permut
auxc1 0) DEF PROC PERMUT(VAR C1,C2 :CARACTERE)
c1c2 1) auxc1
c2aux 2) c1c2
Fin Permut 3) c2aux
4) Fin Permut

137 Bac Scientifique Idoudi Khaled Enseignant :

 T.D.O Locaux
Objet T/N Rôle
aux caractère Variable auxiliaire
 Traduction Pascal
PROGRAM Tri_par_bloc; PROCEDURE Tri_bloc(p1,p2:integer ; VAR
USES wincrt ; T :TAB) ;
TYPE TAB=Array[1..100] of char ; VAR posmin,i :integer ;
VAR FUNCTION Min(pos,p2:integer;T:TAB):
N,D:integer ; integer;
T :TAB ; VAR posmin,i :integer ;
PROCEDURE Saisie(VAR N,D :integer) ; BEGIN
BEGIN posmin:=pos;
for i := pos+1 to p2 do
repeat
if(T[i]<T[posmin]) then
Write('Donner la valeur de N: '); posmin:=i;
Readln(N) ; Min := posmin;
Write('Donner la valeur de D: '); END;
Readln(D) ; PROCEDURE Permut(VAR c1,c2:char);
until(N>=6)and(N<=100)and(N mod D=0) VAR aux :char ;
and(D>1); BEGIN
END; aux :=c1 ;
PROCEDURE Remplir(n:integer;VAR T:TAB); C1 :=c2 ;
C2 :=aux ;
VAR i :integer ;
END;
BEGIN
BEGIN
for i :=1 to n do
for i :=p1 to p2-1 do
begin
repeat begin
Write('T[',i, ']= ') ; Posmin := Min(i,p2,T) ;
Readln(T[i]) ; if posmin <> i then
Until T[i] in ['a'..'z'] ; Permut(T[posmin],T[i]) ;
end;
end;
END; END;
PROCEDURE Afficher(n:integer ;T :TAB) ; PROCEDURE Trier(N,D:integer;VAR T:TAB);
VAR i :integer ; VAR i,p1,p2 :integer ;
BEGIN BEGIN
write('T=') ; For i :=1 to N div D do
for i :=1 to n do Begin
Write(T[i],' ') ; P1 :=(i-1)*D+1 ;
END; P2 := i*D ;
Tri_Bloc(p1,P2,T) ;
End ;
End ;
BEGIN
Saisie(N,D) ;
Remplir(n,T);
Trier(N,D,T) ;
Afficher(n,T) ;

138 Bac Scientifique Idoudi Khaled Enseignant :

 Exercice 38
END.

 Décomposition modulaire du problème

Programme Principal

PROC PROC
PROC Saisie(var N) PROC Supprimer(N,var T) PROC Afficher(N,T)
Remplir(N,var T) Majuscule(N,var T)

 Analyse de programme principal:

 FN Palindrome(ch)
Algorithme de programme
Nom de programme : Chaine_Palindrome principal:
Résultat:PROC Afficher(N,T) 0) Début Chaine_Palindrome
1) PROC Saisie(N)
PROC Supprimer(N,T)
2) PROC Remplir(N,T)
PROC Majuscule(N,T)
3) PROC Majuscule (N, T)
PROC Remplir (N,T)
4) PROC Supprimer(N,T)
PROC Saisie(N)
5) PROC Afficher(N,T)
Fin Chaine_Palindrome
T.D.N.T 6) Fin Chaine_Palindrome
Type
TAB= Tableau de taille 30 et de type chaine de caractères
T.D.O Globaux
Objet T/N Rôle
N Entier stocker la taille de tableau
T TAB Remplir le tableau par N chaines
Saisie Procédure Saisir la taille de tableau
Remplir Procédure Remplir le tableau T par N chaines
Supprimer tous les caractères non alphabétiques des
Supprimer Procédure
chaines du tableau.
Majuscule Procédure Convertir tous les prénoms en majuscule
Afficher Procédure Afficher tous les chaines palindromes du tableau.
 Analyse de la procédure Saisie

Algorithme de la procédure
DEF PROC SAISIE(VAR N:entier) Saisie
Résultat : N 0) DEF PROC SAISIE(VAR N :entier)
N=[]Répéter 1) Répéter
N=donnée("Donner la taille de tableau:") écrire("Donner le nombre de
jusqu’à (N ≥ 2) et (N≤30) tableau: ")
Fin Saisie lire(N)
jusqu’à (N ≥ 2) et (N<30)
2) Fin Saisie
 Analyse de la procédure Remplir
139 Bac Scientifique Idoudi Khaled Enseignant :
DEF PROC REMPLIR (N:ENTIER; VAR T:TAB)
Résultat : T
T =[]Pour i de 1 à N faire  Algorithme de la procédure Remplir
Répéter 0) DEF PROC REMPLIR (N:ENTIER; VAR T:TAB)
T[i]=donnée("T[",i, "]=") 1) Pour i de 1 à N faire
jusqu’à long(T[i])≠0 Répéter
Fin Pour écrire("T[",i, "]=")
Fin Remplir lire(T[i])
T.D.O Locaux jusqu’à long(T[i])≠0
Objet T/N Rôle Fin Pour
2) Fin Remplir
i Entier Compteur
 Analyse de la procédure Majuscule
DEF PROC MAJUSCULE(N:ENTIER; VAR T:TAB)
Résultat : T
Pour i de 1 à N faire  Algorithme de la procédure Majuscule
ChT[i] 0) DEF PROC MAJUSCULE(N:ENTIER; VAR T:TAB)
Pour j de 1 à long(ch) faire 1) Pour i de 1 à N faire
ch[j]Majus(ch[j]) ChT[i]
Fin Pour Pour j de 1 à long(ch) faire
T[i]ch ch[j]Majus(ch[j])
Fin Pour Fin Pour
Fin Majuscule Fin Pour
T.D.O Locaux 2) Fin Majuscule
Objet T/N Rôle
i,j Entier Compteur
ch chaine Chaine
auxiliaire
 Analyse de la procédure Supprimer
DEF PROC SUPPRIMER(N:ENTIER; VAR T:TAB)
Résultat : T
 Algorithme de la procédure
Pour i de 1 à N faire
ChT[i] Supprimer
Pour j de 1 à long(ch) faire 0) DEF PROC SUPPRIMER (N :ENTIER; VAR
Si Non(Majus(ch[j])dans["A".."Z"]) T:TAB)
Alors Efface(ch,j,1) 1) Pour i de 1 à N faire
Fin si ChT[i]
Fin pour Pour j de 1 à long(ch) faire
Fin Pour Si Non(Majus(ch[j])dans["A".."Z"])
i : compteur Alors
Fin Supprimer Efface(ch,j,1)
T.D.O Locaux Fin si
Objet T/N Rôle Fin pour
Fin Pour
i,j Entier Compteur
2) Fin Supprimer
ch chaine Chaine
auxiliaire

140 Bac Scientifique Idoudi Khaled Enseignant :

  Analyse de la procédure Afficher

DEF PROC AFFICHER(N :ENTIER ; T:TAB)

Résultat :Trait
Trait=[] Pour i de 1 à n faire  Algorithme de la procédure Afficher
Si FN Palindrome(T[i]) alors 0) DEF PROC AFFICHER(N:ENTIER; T:TAB)
Ecrire(T[i]) 1) Pour i de 1 à n faire
Fin Si Si FN Palindrome(T[i]) alors
Fin pour Ecrire(T[i])
Fin Afficher Fin Si
Fin pour
2) Fin Afficher
T.D.O Locaux
Objet T/N Rôle
I Entier Compteur
Palindrome Fonction Vérifier si une chaine est palindrome ou non.
 Analyse de la Fonction Palindrome
DEF FN Palindrome (ch :chaine):BOOLEEN
Résultat : Palindrome  ch=ch1  Algorithme de la Fonction
Ch1 =[ch1""] Palindrome
Pour i de long(ch) à 1(pas=-1) faire 0) DEF Palindrome (ch :chaine):BOOLEEN
Ch1ch1+ch[i] 1) Ch1 =[ch1""]
Fin pour Pour i de long(ch) à 1(pas=-1) faire
i:compteur Ch1ch1+ch[i]
Fin Palindrome Fin pour
2) Palindrome ch=ch1
3) Fin Palindrome
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Ch1 chaine Déterminer l’inverse de la chaine ch
 Traduction Pascal
PROGRAM Chaine_Palindrome; PROCEDURE Supprimer(n:integer ; VAR
USES wincrt ; T:TAB) ;
TYPE TAB=Array[1..30] of string; VAR i,j :integer ; ch :string ;
VAR BEGIN
N:integer ; for i :=1 to n do
T :TAB ; begin
PROCEDURE Saisie(VAR N :integer); ch :=T[i] ;
BEGIN for j :=1 to length(ch) do
repeat if NOT(Upcase(Ch[j]) in ['A'.. 'Z'])
Write('Donner la taille de tableau:'); then
Readln(N) ; delete(ch,j,1) ;
until(N>=2)and(N<=30); end;
END; END;
PROCEDURE Remplir(n:integer;VAR

141 Bac Scientifique Idoudi Khaled Enseignant :

T:TAB); PROCEDURE Afficher (n:integer; T:TAB);
VAR i :integer ; VAR i :integer ;
BEGIN FUNCTION Palindrome(ch :string):boolean;
for i :=1 to n do VAR i :integer ; ch1 :string ;
begin BEGIN
repeat Ch1:='';
Write('T[',i,']= '); for i := length(ch) downto 1 do
Readln(T[i]) ; ch1:= ch1+ ch[i];
palindrome := ch=ch1;
Until length(T[i])<>0 ;
END;
end;
BEGIN
END;
For i:=1 to N do
PROCEDURE Majuscule(N :integer ; VAR
If Palindrome(T[i]) then
T:TAB);
Writeln(T[i]);
VAR i,j:integer; ch :string ;
END;
BEGIN
BEGIN
for i :=1 to n do Saisie(N);
Ch:=T[i];
Remplir(N,T);
for j :=1 to length(ch) do
ch[j]:=Upcase(ch[j]); Majuscule(N,T);
END; Supprimer(N,T);
Afficher (N,T);
END.

Exercice 39
 Décomposition modulaire du problème

Programme Principal

PROC Afficher (H)

PROC Saisie(var H)

 Analyse de programme principal :  Algorithme de programme

Nom de programme : Triangle principal:
Résultat: PROC Afficher(H)
0) Début Triangle
PROC Saisie(H)
1) PROC Saisie(H)
Fin Triangle
2) PROC Afficher(H)
3) Fin Triangle

T.D.O Globaux
Objet T/N Rôle
H entier stocker la hauteur d’une chaine

142 Bac Scientifique Idoudi Khaled Enseignant :

 Saisie Procédure Saisir la hauteur d’une chaine
Afficher Procédure Un triangle isocèle d’hauteur H
 Analyse de la procédure Saisie

DEF PROC SAISIE(VAR H :ENTIER) 

Algorithme de la procédure
Résultat : H Saisie
H=[]Répéter 0) DEF PROC SAISIE(VAR H :ENTIER)
H=donnée("Donner la hauteur :
") 1) Répéter
jusqu’à H dans [5..10] écrire("Donner la hauteur : ")
Fin Saisie lire(H)
jusqu’à H dans [5..10]
2) Fin Saisie
 Analyse de la procédure Afficher
DEF PROC AFFICHER(H :ENTIER)
Résultat : Trait  Algorithme de la procédure
Trait=[L2*H-1] Afficher
Pour i de 1 à 2*H-1 faire
0) DEF PROC AFFICHER(H :ENTIER)
Pour j de 1 à L faire
Si j<=i-1 alors 1) [L2*H-1]Pour i de 1 à 2*H-1 faire
Écrire(" ") Pour j de 1 à L faire
Sinon Si j<=i-1 alors
Écrire("*") Écrire(" ")
Fin Si Sinon
Fin Pour Écrire("*")
LL-1 Fin Si
Fin Pour Fin Pour
i : compteur LL-1
Fin Afficher Fin Pour
T.D.O Locaux 2) Fin Afficher
Objet T/N Rôle
i,j Entier Compteurs
L Entier Variable auxiliaire
 Traduction Pascal
PROGRAM Triangle ; PROCEDURE Saisie(VAR H :integer) ;
USES wincrt ; BEGIN
VAR H :integer ; REPEAT
PROCEDURE Afficher(H :integer) ;
Write('Donner la hauteur: ');
VAR i,j,L :integer ;
BEGIN Readln(H) ;
L :=2*H-1 ; UNTIL H in [5..10] ;
for i:=1 to 2*H-1 do END;
begin BEGIN
for j:=1 to L do Saisie(H) ;
begin Afficher(H) ;
if j<=i-1 then
END.
write(' ')

143 Bac Scientifique Idoudi Khaled Enseignant :

 else
write('*');
End;
L:=L-1;
Writeln;
end;
END ;

Exercice 40
 Décomposition modulaire du problème

Programme Principal

PROC Saisie(var ch) FN Coder(ch)

 Analyse
FN OctetValide de programme principal :
(ch)
Nom de programme : Codec
Résultat:
 Algorithme de programme principal:
0) Début Codec
écrire("Octet résultat : ",Res)
1) PROC Saisie(ch)
Res Fn Coder(ch)
2) Res Fn Coder(ch)
PROC Saisie(ch)
3) écrire("Octet résultat : ",Res)
Fin Codec
4) Fin Codec

T.D.O Globaux
Objet T/N Rôle
Ch Chaine de caractère stocker un octet
Saisie Procédure Saisir un octet
Coder Fonction compresser un octet

 Analyse de la procédure Saisie

 Algorithme de la procédure
DEF PROC SAISIE(VAR CH:chaine de caractères)
Saisie
Résultat : ch
ch=[]Répéter 0) DEF PROC SAISIE(VAR ch:chaine
ch=donnée("Donner un octet : ") de caractères)
jusqu’à (long(ch) =8) et 1) Répéter
(FN OctetValide(ch)) écrire("Donner un octet : ")
Fin Saisie lire(ch)
jusqu’à (long(ch) =8) et (FN
OctetValide(ch))
144 Bac Scientifique Idoudi Khaled Enseignant :
2) Fin Saisie
 T.D.O Locaux
Objet T/N Rôle
OctetValide Fonction Tester si une chaine donnée est composée seulement par
les chiffres 0 et 1 ou non
 Analyse de la fonction OctetValide
DEF FN OCTETVALIDE(CH :chaine de caractères) :BOOLEEN
Résultat : OctetValidetest
Test=[testvrai,i1]  Algorithme de la fonction
Répéter OctetValide
Si Non(Ch[i] dans["0".."1"]) 0) DEF FN OCTETVALIDE(CH :chaine de
Alors caractères) :BOOLEEN
Test faux 1) [testvrai,i1]
Fin Si Répéter
ii+1 Si Non(Ch[i] dans["0".."1"])
jusqu’à (test=faux) ou (i>long(ch)) Alors
Fin OctetValide Test faux
Fin Si
ii+1
jusqu’à (test=faux) ou
(i>long(ch))
2) OctetValidetest
3) Fin OctetValide
T.D.O Locaux
Objet T/N Rôle
i Entier Compteur
Test booléen Tester si une chaine donnée est composée seulement par les
chiffres 0 et 1 ou non
 Analyse de la fonction Coder
DEF FN CODER(CH :chaine de caractères) : chaine de caractères
Résultat : Coder ch1
[ch1"",i1]
répéter
ji+1
Tant que (CH[i]=CH[j]) et (j<=long(ch)) faire
Jj+1
Fin tant que  Algorithme de la fonction Coder
si j-i≠1 alors 0) DEF FN CODER(CH :chaine de
Convch(j-1,b) caractères):chaine de caractères
Ch1ch1+b+CH[i] 1) [ch1"",i1]
Sinon répéter
Ch1ch1+CH[i] ji+1
Fin si Tant que (CH[i]=CH[j]) et (j<=long(ch))
ij faire
Jj+1
145 Bac Scientifique Fin tant que Idoudi Khaled Enseignant :
si j-i≠1 alors
Convch(j-i,b)
Ch1ch1+b+CH[i]
Jusqu’à i>long(ch)
i :compteur
Fin Coder

T.D.O Locaux
Objet T/N Rôle
i,j Entier Compteurs
B chaine Chaine auxiliaire
Ch1 chaine Contient le résultat de compression
 Traduction Pascal
PROGRAM Codec ; FUNCTION Coder(ch:string) :String;
USES wincrt ; VAR i,j :integer ;
VAR Ch,res :string ; Ch1,b:string ;
PROCEDURE Saisie(VAR ch :string) ; BEGIN
FUNCTION OctetValide(ch :string):Boolean; Ch1:='' ; i:=1 ;
VAR Repeat
i :integer ; test :boolean ; J :=i+1 ;
BEGIN While (ch[i]=ch[j])and(j<=length(ch))do
Test :=true ; i :=1 ;
J :=j+1 ;
Repeat
if j-i>1 then
If NOT(Ch[i] in['0'..'1']) then
Test :=false ; begin
i :=i+1 ; str(j-i,b);
Until (test=false)OR(i>length(ch)) ; Ch1:=ch1+b+CH[i];
OctetValide :=test ; End
END ; else
BEGIN Ch1:=ch1+CH[i];
REPEAT i:=j;
Write('Donner un octet: ');
Readln(ch) ; Until i>length(ch);
UNTIL (length(ch)=8) AND Coder := ch1;
(OctetValide(ch)) ; END ;
END; BEGIN
Saisie(ch) ;
Res := Coder(ch);
write('Octet résultat : ',Res) ;

END.

146 Bac Scientifique Idoudi Khaled Enseignant :