Chapitre 5: Les sous-programmes Leçon N°1 : l'analyse modulaire

Zinoubi Thameur 1 Lycée 2 Mars 1934 SBZ 1

Chapitre 5: Les sous-programmes Leçon N°1 : l’analyse modulaire

L’analyse modulaire permet de diviser un grand problème en sous problèmes (module) de difficultés

inférieurs pour :

Diminuer les instructions qui se répètent,

Faciliter les taches difficiles.

Exemple :

Soit l'algorithme suivant:

0) Début Exemple

1) [CH1''''] Pour i de P à (P+N)-1 Faire

CH1CH1 +CH[i]

Fin Pour

2) Ecrire (CH1)

3) Fin Exemple

Sachant que :

CH et CH1 : deux chaînes,

N, P et i trois entiers.

o Donner le résultat du programme si CH = "Bonjour", P = 4 et N = 4.

o Déduire le rôle de ce programme

Ce programme permet de copier de CH, N caractères à partir de la position P et le résultat se sera

affecté dans la chaîne CH1.

CH1 Sous-chaine (CH, P, N)

Sous-chaine est une fonction prédéfinie qui facilite la tache à l'utilisateur: au lieu d'écrire le bloc d'instruction

N°1 on l'appelle seulement par les paramètres convenables.


La différence entre :


Efface (CH, P, N)

La 1ère est une fonction la 2ème est une procédure.

Remarques :

Le sous-programmes permet de découper un gros programme en morceaux plus petits et plus simples à coder

et à comprendre, et permet d'éviter la répétition de plusieurs morceaux identiques. Il possède un nom, des

variables, des instructions, un début et une fin. En effet, l'exécution d'un sous-programme est demandée par le

programme principal (ou un autre sous-programme) grâce à une instruction spécifique qu'on nomme APPEL.

Le programme principal est l'ensemble d'instruction qui s'exécute au lancement de l'application.

Prob

S-P 2

S-P 3

S-P 1

S-P 11 S-P 12

Zinoubi Thameur Lycée 2 Mars 1934 SBZ 2

Leçon N°2: Les fonctions: 1. Définition :

Une fonction est une suite d’instructions décrivant un action simple ou composée, à laquelle on affecte un nom,

qui peut retourner q’un seul résultat. La structure d’une fonction est analogue à la structure d’un algorithme.

2. Syntaxe : Au niveau de l’analyse :

DEF FN Nom_ fonction (liste des paramètres) :type_fonctin

Résultat = Nom_ fonction ………

…………………………….

……………………………

Au niveau de l’algorithme

0) DEF FN Nom_ fonction (liste des paramètres) :type_fonctin

1) ……..….

i-1) Nom_ fonction résultat

i) FIN Nom_ fonction

Au niveau de la traduction en Pascal

Function Nom _ fonction (liste des paramètres) :type_fonctin;

VAR Les déclarations;

BEGIN

Instructions de la fonction;

Nom _ fonction := résultat ;

END;

3. Activité : Ecrire une analyse, un algorithme qui permet de lire deux entiers p et n (n ≥ p ≥ 0) et de calculer et afficher la

combinaison de p objets parmi n.

L’analyse du programme principal: Résultat = Ecrire(C ).

C =[ ] C FN Fact(n)/( FN Fact(p) * FN Fact(n-p))

(n,p) =[ ] Répéter

n, p= Données

Jusqu'à (n ≥ p) et (p ≥ 0)

Fin Combinaison

L’Algorithme du programme principal: 0) Début Combinaison

1) Répéter

Ecrire ('' Donner n et p''), Lire (n,p)

Jusqu'à (n ≥ p) et (p ≥ 0)

2) C FN Fact (n)/ (FN Fact (p) * FN Fact (n-p))

3) Ecrire (C)

4) Fin Combinaison

)!(!

!

pnp

nC p

n

Paramètres Effectifs

L’appel de la fonction

Zinoubi Thameur Lycée 2 Mars 1934 SBZ

Tableau de déclaration des objets globaux

Objet Nature/ Type Rôle

n

p

C

Fact

Entier

Entier

Réel

Fonction

Le 1er entier

Le 2ème entier

Contient la combinaison de p parmi n.

Calculer la factorielle d’un entier.

L’analyse de la fonction Fact:

DEF FN Fact ( x : entier ) : entier

Résultat = Fact f

f =[ ] Selon x faire

0 : f 1

Sinon [f 1] Pour i de 1 à x Faire

f f * i

Fin Pour

FinSelon

Fin Fact

L’Algorithme de la fonction Fact:

0) DEF FN Fact (x : Entier) : entier

1) Selon x faire

0 : f 1

Sinon [f 1] Pour i de 1 à x Faire

f f * i

Fin Pour

FinSelon

2) Fact f

3) Fin Fact

Tableau de déclaration des objets locaux:

Traduction en Turbo pascal :

Program Act ;

Uses wincrt ;

Var n,p: integer ;

C : Real ;

Function Fact ( X: integer): integer ;

Var f,i : integer; Begin

Case X of

0 : f : =1 ;

Else f : = 1;

For i : = 1 to X do

f : = f * i ;

End ;

Fact : = f ;

End;

Begin

Repeat

Writeln (' Donner n et p') ;

Readln (n,p) ;

Until (n >= p) AND (p >= 0) ;

C : = Fact(n)/( Fact(p) * Fact(n-p)) ;

Writeln(' la combinaison est = ',C) ;

End.


i

f

Entier

Entier

Le compteur

Contient la factorielle

Paramètres formels


Remarques : L’appel de la fonction dans le programme principale comme suit :

C FN Fact (n)/ (FN Fact (p) * FN Fact (n-p))

Paramètres formels : ce sont les paramètres qui se trouvent dans l’entête de la fonction.

Paramètres effectifs : ce sont les paramètres qui se trouvent dans l’appel de la fonction.

Une variable globale : est une variable déclarée dans la partie déclaration des variables du

programme principal et utilisable par le programme principal et les sous-programmes.

Une variable locale : est une variable déclarée dans le sous-programme et n'est utilisable qu'à

l'intérieur de ce sous-programme.

4. Application : Ecrire une analyse, un algorithme qui permet de remplir un tableau T de N entiers positifs (3 ≤N ≤6)

et de déterminer la moyenne arithmétique de ce tableau et d’afficher le nombre d’éléments supérieur

à cette moyenne.

L’analyse :

Résultat = Ecrire (NB)

[NB 0] Pour i de 1 à N faire

Si T[i] > M alors NB NB +1

FinSi

FinPour

M FN MOYENNE(T, N)

Pour i de 1 à N Faire

Répéter

T [i]= Donnée (‘’Donner l’élément N°’’, i)

Jusqu'à (T [i]>0)

Fin Pour

Répéter

N= Donnée ('’Donner N'')

Jusqu'à N dans [3..6]

L’Algorithme

0) Début APP1

1) Répéter

Ecrire ('’Donner N''); Lire (N)


2) Pour i de 1 à N Faire

Répéter

Ecrire (‘’Donner l’élément N°’’, i)

Lire (T [i])

Jusqu'à T [i]>0

Fin Pour

3) M FN MOYENNE (T, N)

4) [NB 0] Pour i de 1 à N faire

Si T[i] > M alors NB NB +1

FinSi

FinPour

4) Ecrire (NB)

5) Fin APP1

Tableau de déclaration des objets globaux


N

i

M

T

MOYENNE

NB

Entier

Entier

Entier

Tableaux de N entiers

Fonction

Entier

Contient la taille du tableau

Le compteur

La moyenne arithmétique du tableau

Contient N entiers positifs

La fonction qui retourne la moyenne du tableau

Le nombre d’élément supérieur à la moyenne


L’analyse de la fonction:

DEF FN Maxi (T : Tab, N : entier) : Entier

Résultat = Maxi M

[M T [1]] Pour i de 2 à N Faire

Si (T[i]>=M) alors M T[i]

FinSi

Fin Pour

L’Algorithme de la fonction

0) DEF FN Maxi (T : Tab, N : entier) : Entier

1) [M T [1]] Pour i de 2 à N Faire

Si (T[i]>=M) alors M T[i]

FinSi

Fin Pour

2) Maxi M

3) Fin Maxi

Tableau de déclaration des objets locaux


M Entier Contient l’élément maximum du tableau


Leçon N°3 : LES PROCEDURES : 1. Activité :

Ecrire un algorithme qui permet de remplir deux tableaux T1 et T2 de N entiers composés de deux

chiffres avec N compris entre 3 et 6 et de remplir et afficher un 3ème tableau T.

Exemple : Si N = 5

L’algorithme : 0) Début Act1

1) Répéter

Ecrire (‘’Donner N’’) ; Lire (N)



Répéter

Ecrire (‘’Donner l’entier N°’’, i) Lire (T1 [i])

Jusqu'à T1 [i] Dans [10..99]

Fin Pour


Répéter

Ecrire (‘’Donner l’entier N°’’,i) Lire(T2 [i])

Jusqu'à T2 [i] Dans [10..99]

Fin Pour


T[i]= (T1 [i] Div 10)*1000 + (T1 [i] Mod 10)*10 + (T2 [i] Div 10)* 100+ (T2 [i] Mod

10)

Fin Pour


Ecrire (T[i])

Fin Pour

6) Fin Act1

Remarques :

Les traitements 2 et 3 permet de remplir deux tableaux pour cela on peut utiliser un seul

module (permet de remplir un tableau de N entiers composé de 2 chiffres) et on l’appelle de

deux manières.

Rendre les 5 blocs 5 appels de 4 modules (fonctions et procédures).

2. Définition :

Une procédure est une suite d’instructions décrivant une action simple ou composée, à laquelle on

affecte un nom, qui peut retourner zéro ou plusieurs résultats. Sa structure est analogue à la

structure d’un algorithme.

3. Syntaxe : Au niveau de l’analyse

DEF PROC Nom_procédure (listes des paramètres : les types)

Résultat = ……..

…………

Au niveau de l’algorithme

0) DEF PROC Nom_procédure (listes des paramètres : les types)

T1 = 12 25 54 99 46

T2 = 54 94 37 59 67

Alors T sera 1524 2954 5347 9599 4667


i-1)…………

i) FIN Nom_procédure

Au niveau Traduction en Pascal

PROCEDURE Nom _ procédure (listes des objets : les types);

VAR déclaration des objets locaux;

BEGIN

…………………..

……………………

END ;

Correction de l’activité : L’analyse :

Résultat = Proc Affichage (T, N)

Pour i de 1 à N faire

T[i] FN Fusion (T1,T2,i)

FinPour

Proc Remplissage (T2, N)

Proc Remplissage (T1, N)

Proc Saisir (N)

L’algorithme

0) Début FusionTab

1) Proc Saisir (N)

2) Proc Remplissage (T1, N)

3) Proc Remplissage (T2, N)

4) Pour i de 1 à N faire

T[i] FN Fusion (T1, T2, i)

FinPour

5) Proc Affichage (T, N)

6) Fin FusionTab

Tableau de déclaration des nouveaux types :

Type

Tab=Tableaux de N entiers

Tableau de déclaration des objets globaux :


N

i

T

T1

T2

Saisir

Remplissage

Fusion

Affichage

Entier

Entier

Tab

Tab

Tab

Procédure

Procédure

Fonction

Procédure

La taille des tableaux

Compteur

Tableaux des entiers fusionnés

Le premier Tableau

Le deuxième Tableau

Permet de saisir N

Permet de remplir un tableau

Permet de fusionner deux entiers en un seul

Permet d’afficher un tableau

L’analyse de la procédure Saisir :

DEF PROC Saisir (Var N : entier)

Résultat = N

Répéter

N = Donnée (‘’Donner N’’)


L’algorithme de la procédure Saisir :

0) DEF PROC Saisir (Var N : entier)

1) Répéter

Ecrire (‘’Donner N’’) ; Lire (N)


2) Fin Saisir

L’analyse de la procédure Remplissage :

DEF PROC Remplissage (Var T : tab ; N : entier)

Résultat = T


Répéter

T [i]= Donnée ('' Donner l’élément N°'', i),

Jusqu'à (T [i] dans [10..99])

Fin Pour

L’algorithme de la procédure Remplissage:

0) DEF PROC Remplissage (Var T : tab ; N : entier)


Répéter

Ecrire ('' Donner l’élément N°'', i), Lire (T[i])

Jusqu'à (T[i] dans [10..99])

Fin Pour

2) FIN Remplissage

L’analyse de la fonction Fusion :

DEF FN Fusion (T1, T2 : tab ; i : entier) : entier

Résultat = Fusion X

X (T1[i] Div 10)*1000 + (T1[i] Mod 10)*10 + (T2[i] Div 10)*100 + (T2[i] Mod 10)

L’Algorithme de la fonction:

0) DEF FN Fusion (T1, T2 : tab ; i : entier) : entier

1) X (T1[i] Div 10)*1000 + (T1[i] Mod 10)*10 + (T2[i] Div 10)*100 + (T2[i] Mod 10)

2) Fusion X

3) Fin Fusion

Tableau de déclaration des objets locaux

L’analyse de la procédure Affichage :

DEF PROC Affichage (T : tab ; N : entier)

Résultat = T


Ecrire (T[i]),

Fin Pour

L’algorithme de la procédure Affichage:

0) DEF PROC Affichage (T : tab ; N : entier)


Ecrire (T[i])

Fin Pour

2) FIN Remplissage

Traduction Turbo Pascal:

Program FusionTab;

Uses wincrt;

Type TAB = array [1.. 6] of integer;

Var T, T1, T2: TAB;

i, N: integer;

{Cette procédure permet de saisir un entier N }


X Entier L’entier fusionné

L‘appel de la fonction

L‘appel de la fonction

Procedure Saisir (Var N: integer);

Begin

Repeat

Writeln(' Donner N'); readln(N);

Until (N in [3 .. 6]);

End;

{Cette procédure permet de remplir un tableau de N entiers}

Procedure Remplissage (Var T : TAB; N:integer);

Begin

For i:= 1 to N do

Repeat

Writeln (' Donner l''élément N°', i); readln (T[i]);

Until (T[i] in [10 .. 99]);

End;

{Cette fonction permet de fusionner deux entiers en un seul entier}

Function Fusion (T1, T2: tab; i: integer): integer;

Var X : integer ;

Begin

X: = (T1 [i] Div 10)*1000 + (T1 [i] Mod 10)*10 + (T2 [i] Div 10)*100 + (T2 [i] Mod 10);

Fusion: = X;

End ;

Begin

Saisir (N);

Remplissage (T1, N);

Remplissage (T2, N);

For i: = 1 to N do

T[i]:= Fusion (T1, T2, i);

Affichage (T, N);

End.

Remarques :

La déclaration d'une Procédure ou fonction en Pascal se trouve après la déclaration des variables

globales.

L’appel de la procédure dans le programme principale comme suit : Remplissage (T1, N)

Les paramètres effectifs et les paramètres formels doivent s’accorder du point de vue nombre et ordre

et leurs types doivent être identiques ou compatibles.

4. Le passage de paramètres: C’est l’échange des paramètres formels et effectifs entre le programme appelant et la procédure appelé.

Dans la déclaration de la procédure on a : DEF PROC Remplissage (Var T : tableau ; N : entier)

Les paramètres formels sont N et T, Mais ils ont deux modes de passage :

Passage de paramètre par valeur pour N.

Passage de paramètre par variable pour T.

Si le paramètre formel est précédé par le mot VAR, le mode du passage du paramètre effectif correspondant

est par variable, Sinon ce mode est par valeur.

a) Passage de paramètre par valeur :

Le programme appelant transmet des valeurs à la procédure appelée. Toute modification du paramètre

formel est sans conséquent sur la valeur du paramètre effectif. Si la valeur de N change dans la procédure

cette modification n’est pas transmet au programme appelant.

Programme Appelant Procédure appelé

N N

b) Passage de paramètre par variable :

Le programme appelant transmet des valeurs à la procédure appelée. Toute modification du paramètre

formel est transmet au paramètre effectif. Si les valeurs de T changent dans la procédure ces modifications

sont transmet au programme appelant.

Programme Appelant Procédure

T T

Toute modification du paramètre formel, entraîne automatiquement la modification de la valeur du

paramètre effectif.

Chapitre 5: Les sous-programmes Leçon N°1 : l'analyse modulaire

Documents

Transcript of Chapitre 5: Les sous-programmes Leçon N°1 : l'analyse modulaire