IUT Arles– Info 1 – Essai (1 , 2, 3)

TD 7 Les procédures et les fonctions

1ère année – Matière AP (Algorithmique) Appel incorrect car les paramètres formels B et C sont en entrée / Sortie : il doit leur correspondre des
variables, pas des constantes.
2 – Essai (X, Y, Z)
CORRIGE : Les procédures et les fonctions Au début de l’exécution de la procédure, les paramètres A, B et C valent respectivement 3, 7 et 11. A la
fin de la procédure, leurs valeurs sont devenues 4, 22 et 14. Après l’exécution de la procédure, X, Y, Z
Exercice I : ont pour nouvelles valeurs 3, 22 et 14.
1 - Trouver le résultat fourni par l’algorithme : 3 – Essai (Z, Y, X)
Procédure SomCar ( →X1 : numérique, → X2 : numérique, ↔S : numérique)
Début Au début de l’exécution de la procédure, les paramètres A, B et C valent respectivement 11, 7 et 3. A la
X1 ← X1 * X1 fin de la procédure, leurs valeurs sont devenues 12, 22 et 6. Après l’exécution de la procédure, X, Y, Z
X2 ← X2 * X2 ont pour nouvelles valeurs 6, 22 et 11.
S ← X1 + X2 4 – Essai (1+X*10, Y, Z)
Fin
L’expression 1+X*10 est évaluée avant que sa valeur soit transmise au paramètre 1. Au début de
Programme principal : l’exécution de la procédure, les paramètres A, B et C valent respectivement 31, 7 et 11. A la fin de la
Variables X, Y, Z : numériques procédure, leurs valeurs sont devenues 32, 22 et 14. Après l’exécution de la procédure, X, Y, Z ont pour
X ← 3 nouvelles valeurs 3, 22 et 14.
Y ← 4 5 – Essai (X, X, Z)
Z ← 0
SomCar(X, Y, Z) Au début de l’exécution de la procédure, les paramètres A, B et C valent respectivement 3, 3 et 11. A la
Ecrire X, « ^2 + », Y, « ^2 = », Z fin de la procédure, leurs valeurs sont devenues 4, 22 et 14. Après l’exécution de la procédure, X, Y, Z
Fin du programme principal ont pour nouvelles valeurs 22, 7 et 14. On a pu utiliser deux fois le paramètre effectif X sans problème.
Ce programme affiche pour résultat « 3^2+4^2 = 25 ». On remarquera que la procédure, bien qu’elle ait 6 – Essai (X, Y, Y)
modifié les valeurs des paramètres formels X1 et X2, n’a pas modifié la valeur des paramètres effectifs X Au début de l’exécution de la procédure, les paramètres A, B et C valent respectivement 3, 7 et 7. A la fin
et Y car ils étaient en entrée (passés par valeur). de la procédure, leurs valeurs sont devenues 4, 25 et 25. Après l’exécution de la procédure, X, Y et Z ont
2 - Remplacer dans ce programme la procédure par une fonction. pour nouvelles valeurs 3, 25 et 11. On a pu utiliser deux fois le paramètre effectif X, mais comme cette
Avec une fonction, ce programme devient : fois ci il correspondait à deux paramètres formels en entrée sortie, des résultats curieux ont été obtenus
Fonction SomCar ( →X1 : numérique, → X2 : numérique) : numérique (on aurait pu croire que C aurait valu 7 + 3 = 10, mais l’affectation B ← 22 a modifié aussi la valeur de Y
Début
et celle de C). Bien sûr, ce genre de situation est à éviter absolument car l’algorithme ainsi conçu produit
X1 ← X1 * X1
X2 ← X2 * X2 des résultats presque imprévisibles et se montre particulièrement peu clair.
Résultat X1 + X2 Ö On peut utiliser plusieurs fois la même variable comme paramètre effectif sous réserve que,
Fin parmi les paramètres formels qui lui correspondent un seul soit en entrée / sortie.
Programme principal :
Variables X, Y, Z : numériques
Exercice III : Quels sont les résultats produits par l’algorithme suivant :
Procédure Max (→X : numérique, →Y : numérique, ↔ M : numérique)
X ← 3
Début
Y ← 4
A ← X
Z ← SomCar(X, Y)
Si A < Y alors
Ecrire X, « ^2 + », Y, « ^2 = », Z
A ← Y
Fin du programme principal
Fsi
Remarque :
M ← A
On peut aussi écrire :
Fin // de la procédure
Ecrire X, « ^2 + », Y, « ^2 = », SomCar(X, Y)
Début du programme principal
Exercice II : Une procédure est déclarée par : Variables A, B, C : numériques
Procédure Essai (→A : numérique, ↔B : numérique, ↔ C : numérique)
Début A ← 3
B ← 7
A←A+1 C ← 0
B ← 22 Max (A, B, C)
C←C+3 Ecrire « Le maximum de », A, « et », B, « est », C
Fin Fin du programme principal
Parmi les appels suivants certains ne sont pas corrects, expliquer pourquoi. Pour les autres, trouver les On aurait souhaité que cet algorithme fournisse pour résultat « Le maximum de 3 et 7 est 7 », mais il
valeurs des paramètres A, B, C au début et à la fin de son exécution, des variables X, Y et Z ensuite. donne « Le maximum de 7 et 7 est 7 ». A n’est pas le nom d’un paramètre ni d’une variable locale pour la
Avant chacun des appels, on effectue : procédure qui utilise donc la variable A du programme principal comme variable globale et la modifie en
X←3 lui affectant d’abord 3, puis 7. Si par malchance les valeurs initiales de A et B avaient été respectivement
Y←7 de 7 et 3, on ne se serait aperçu de rien et on n’aurait découvert ce problème que le jour où les valeurs de
Z ← 11 A et B auraient été dans l’ordre croissant.
La modification subreptice d’une variable globale par une procédure ou une fonction (effet de bord) est
une cause de mauvais fonctionnement de certains algorithmes souvent difficile à repérer et même à
déceler.
Ö Pour éviter tout effet de bord, il faut que toutes les variables utilisées dans les procédures et
les fonctions soient soit des paramètres, soit des variables locales.
Les quatre algorithmes produisent des résultats différents en raison de la modification des
Exercice IV : Les algorithmes suivants ont été écrits par un mauvais programmeur, particulièrement paramètres effectifs lors des passages par adresse, et de leur conservation lors des passages
maladroit dans les choix des noms des paramètres et peu soucieux d’éviter les effets de bords. Seuls les par valeur.
modes de transmission des paramètres diffèrent entre ces quatre algorithmes. Que produisent ils ? Version 1 Version 2 Version 3 Version 4
Version 1 Version 2 11 11 11 11
Procédure Deux (↔A : numérique) Procédure Deux (↔A : numérique) 13 13 12 12
Début Début 15 13 12 13
A ← A + 1 A ← A + 1 15 15 13 13 11 11 12 12
Ecrire A Ecrire A
Fin Fin
11 11 11 11
17 15 13 14
Procédure Un (↔ B : numérique) Procédure Un (→ B : numérique) 13 13 12 12
Début Début 17 13 15 13 12 11 13 11
A ← A + 1 A ← A + 1 17 13 15 11 12 10 13 11
Deux (A) Deux (A)
B ← B +1 B ← B +1
Deux (B) Deux (B) ECRITURE DE PROCEDURES ET DE FONCTIONS
Ecrire A, B Ecrire A, B
Fin Fin Exercice V : Ecrire une fonction qui permet de savoir si un entier est divisible par un autre.
On pourra utiliser un nouveau type nommé logique afin de renvoyer le résultat
Début programme principal Début programme principal Solution
Variables A, B : numériques Variables A, B : numériques fonction logique Divise (var entier a, var entier b)
A ← 10 A ← 10 début
Deux (A) Deux (A)
Un (A) Un (A) si (a mod b = 0)
B ← 10 B ← 10 retourner vrai;
Deux (B) Deux (B) sinon
Un (B) Un (B) retourner faux;
Ecrire A, B Ecrire A, B
Fin du programme principal Fin du programme principal fin
Version 3 Version 4
Procédure Deux (→A : numérique) Procédure Deux (→A : numérique) qui peut s'utiliser : si (Divise (x, y) = vrai)
Début Début
A ← A + 1 A ← A + 1 Exercice VI : Créer un petit ensemble de procédures et de fonctions permettant de manipuler
Ecrire A Ecrire A facilement les heures et les minutes et composé de :
Fin Fin
1- La fonction Minutes, qui calcule le nombre des minutes correspondant à un nombre
Procédure Un (→ B : numérique) Procédure Un (↔ B : numérique) d’heures et un nombre de minutes donnés.
Début Début Fonction Minutes ( →H : numérique, → M : numérique) : numérique
A ← A + 1 A ← A + 1 Début
Deux (A) Deux (A) Résultat H * 60 + M
B ← B +1 B ← B +1 Fin
Deux (B) Deux (B) 2- La fonction ou la procédure HeuresMinutes qui réalise la transformation inverse de la
Ecrire A, B Ecrire A, B fonction Minute.
Fin Fin
Pour HeuresMinutes, il y a deux résultats à fournir, une fonction ne peut convenir, il
Début programme principal Début programme principal faut donc écrire une procédure comportant trois paramètres :
Variables A, B : numériques Variables A, B : numériques La durée (entrée), l’heure (sortie) et les minutes (sortie).
A ← 10 A ← 10 Procédure HeuresMinutes (→ Durée : numérique, ↔ H : numérique, ↔
Deux (A) Deux (A) M : numérique)
Un (A) Un (A) Début
B ← 10 B ← 10 H ← Durée Div 60 // division entière
Deux (B) Deux (B) M ← Durée – 60 * H
Un (B) Un (B) Fin
Ecrire A, B Ecrire A, B 3- La procédure AjouteTemps qui additionne deux couples de données heures et minutes
Fin du programme principal Fin du programme principal en utilisant les deux fonctions précédentes.
 La procédure AjouteTemps reçoit quatre paramètres en entrée, fournit deux paramètres en Si ((annee Mod 4 = 0 et annee Mod 100 <> 0) ou (annee Mod
sortie. La variable locale MinuteEnTout sert à stocker un résultat intermédiaire, mais elle 400 = 0)) alors
// Année bissextile
n’est pas indispensable. Résultat 1
Procédure AjouteTemps (→H1 : numérique, → M1 : numérique, → H2 : Sinon
numérique, → M2 : numérique, ↔Hsomme : numérique, ↔Msomme : Résultat 0
numérique) Fsi
Variables MinuteEnTout : numérique Fin
Début Si l’année est bissextile alors le mois de février à 29 jours.
MinuteEnTout ← Minutes (H1, M1) + Minutes (H2, M2) Il en a 28 sinon
HeuresMinutes(MinuteEnTout, Hsomme , Msomme)
Fin 4- Utiliser ces fonctions pour écrire une fonction retournant le nombre de jours pour un
mois et une année donnés.
Fonction Nombre_de_jours (→mois : numérique, → annee :
numérique) : numérique
ON PEUT INTRODUIRE LE TYPE BOOLEEN (VRAI ET FAUX) Variable est31, est30 : numériques

Début
est31 ←EstUnMoisDeTrenteEtUnJours(mois)
est30 ←EstUnMoisDeTrenteJours(mois)
Exercice VII : Cet exercice permet de compléter les procédures et fonctions de l’exercice Si (est31 = 1) alors
précédent Résultat 31
1- Créer une fonction qui permet de dire si un mois a 30 jours ou non. Cette fonction Sinon
renverra 1 si c’est le cas et 0 sinon. Si (est30 = 1) alors
1 2 3 4 5 6 7 8 9 10 11 12 Résultat 30
Sinon
Janv. Fév. Mars Avril Mai Juin Juil Aout Sept Oct Nov Dec // mois de février
31 28 ou 31 30 31 30 31 31 30 31 30 31 // regarder si bissextile
29 Si (EstUneAnneeBissextile(annee) = 1) alors
Résultat 29
Fonction EstUnMoisDeTrenteJours ( → mois : numérique) : Sinon
numérique Résultat 28
Début Fsi
Si (mois = 4 ou mois = 6 ou mois = 9 ou mois = 11) alors Fsi
Résultat 1 Fsi
Sinon Fin
Résultat 0 5- Ecrire un programme principal permettant à l’utilisateur d’entrer un numéro de mois
Fsi (entre 1 et 12) et une année (entre 1582 et 2003), qui seront ensuite passés en
Fin paramètres à la fonction Nombre_de_jours().
Il faut tester la validité des mois et années.
2- Créer une fonction qui permet de dire si un mois a 31 jours ou non. Cette fonction
renverra 1 si c’est le cas et 0 sinon.
Fonction EstUnMoisDeTrenteEtUnJours ( → mois : numérique) : INTRODUIRE LE TYPE CHAINE DE CARACTERES
numérique
Début Exercice VIII : On désire gérer un tableau contenant une liste de noms. Pour cela, on décide
Si (mois = 1 ou mois = 3 ou mois = 5 ou mois = 7 ou mois de répéter l’affichage d’un menu et l’exécution de la commande choisie par l’utilisateur. Le
= 8 ou mois = 10 ou mois = 12) alors
menu sera de la forme qui suit :
Résultat 1
Sinon Veuillez frapper :
Résultat 0 + la lettre V pour voir la liste
Fsi + La lettre S pour supprimer un nom de la liste
Fin + La lettre A pour ajouter un nom à la liste
3- Créer une fonction qui permet de dire si une année est bissextile ou non. Cette + La lettre pour rechercher si un nom est dans la liste
fonction renverra 1 si c’est le cas et 0 sinon. + La lettre T pour terminer.
Pour qu’une année soit bissextile, il suffit que l’année soit un nombre divisible par 4 et
non divisible par 100, ou alors qu’elle soit divisible par 400. Cette gestion exige d’abord qu’un même nom ne figure pas deux fois dans la liste, ensuite
Fonction EstUneAnneeBissextile ( → annee : numérique) :
numérique
qu’un nouveau nom soit ajouté, au début de la liste, à la fin de la liste, ou après un autre nom,
Début selon le choix de l’utilisateur.
On pourrait écrire un « gros » algorithme monolithique, mais pour que le programme Si Fin alors insérer en place N+1
principal soit le plus simple donc le plus clair possible, on y fera apparaître des appels de Si Après alors
procédures. Les écritures séparées de ces procédures mettront en évidence l’intérêt de Choisir après qui
nouvelles procédures et fonctions qui leur rendront des services identiques. On ne détaillera Si qui existe alors insérer après
pas les algorithmes des diverses procédures tant que le programme ne sera pas entièrement Sinon erreur
organisé.
Voir :
La première étape d’écriture des programmes offrant un menu est toujours très simple, dans le Passer toute la liste en revue avec un Répéter pour
style suivant :
Rechercher :
Tableau Liste [Nmax] : Chaînes de caractères Choisir le nom à rechercher
Variable N : numérique Si ce nom existe alors
Variable choix : caractère Ecrire « Présent »
Sinon
Début Ecrire « Absent »
N←0 On a fait apparaître l’intérêt d’une fonction Existe, d’une procédure Insérer, d’une fonction
Répéter Place donnant la place d’un nom dans la liste et aussi des procédures Erreur et LireNom.
Ecrire « Tapez : » Détaillons les maintenant.
Ecrire « V pour voir la liste »
Ecrire « S pour supprimer un nom de la liste » Procédure Erreur(→Message : chaîne de caractère)
Ecrire « A pour ajouter un nom au début de la liste » Début
Ecrire « Action impossible car », Message
Ecrire « R pour rechercher si un nom est dans la liste » Fin
Ecrire « T pour terminer »
Procédure LireNom (↔Nom : chaîne de caractères, → Question : chaîne
Lire choix de caractères)
Si Choix = ‘V’ alors Voir(T,N) Fsi Début
Ecrire Question
Si Choix = ‘S’ alors Supprimer (T,N) Fsi Lire Nom
Si Choix = ‘R’ alors Recherche (T,N) Fsi Fin
Si Choix = ‘A’ alors Ajouter (T,N) Fsi
Jusqu’à Choix = ‘T’ Procédure Insérer (↔tableau T[Nmax] : Chaînes de caractères, ↔N :
Fin numérique, → Qui : Chaîne de caractère, → Endroit : numérique)
On remarque qu’il n’est pas nécessaire dans la lecture de Choix que la réponse soit correcte Variable i : numérique
Début
(V, S, R, A ou T) car une autre réponse ne provoque l’exécution d’aucune procédure et la // faire éventuellement un trou pour loger le nouveau nom
boucle répéter fait afficher de nouveau le menu et effectuer une nouvelle lecture de la variable Répéter pour i = N en descendant jusqu’à Endroit faire
Choix. T[i+1] ← T[i] // boucle à faire absolument en descendant
FinPour
T[Endroit] ← Qui
Commençons par bâtir le cadre des procédures : N ← N + 1
Supprimer : Fin
Choisir le nom à supprimer
Si ce nom existe alors le supprimer Fonction Place (→tableau T[Nmax] : Chaîne de caractère, → N :
Sinon fournir un message d’erreur numérique, → Qui : chaîne de caractère) : numérique
Variable i : numérique
Début
Ajouter : // le résultats sera zéro si l’élément n’est pas trouvé
Choisir le nom à ajouter T[N+1] ← Qui // on utilise la méthode sentinelle
Si ce nom existe i ← 1
Alors Tant que T[i] ≠ Qui faire
fournir un message d’erreur i ← i + 1
FinTantque
Sinon Si i > N alors i ← 0 Fsi
Choisir Début, Fin, Après Résultat i
Si Début alors insérer en place 1 Fin
 Erreur(« Ce nom n’est pas dans la liste »)
Fonction Existe (→ tableau T[Nmax] : Chaîne de caractère, ↔ N : Fsi
numérique, → Qui : Chaîne de caractère): numérique Fin
Début
Si Place (T, N, Qui) ≠ 0 alors Existe ← 1 Procédure Voir (→ tableau T[Nmax] : Chaîne de caractère, → N :
Sinon numérique)
Existe ← 0 Variable i : numérique
Fsi Début
Fin Ecrire « Liste des noms »
Répéter pour i = 1 à N faire
Procédure Ajouter (↔tableau T[Nmax] : Chaîne de caractère, ↔ N : Ecrire T[i]
numérique) FinPour
Variables Qui, Après : Chaînes de caractères Fin
Variable Mode : caractère
Début Exercice IX (Exercice Complémentaire) : Calcul de l’impôt sur le revenu
LireNom (Qui, « Qui voulez vous ajouter ?) Remarque : Pour les besoins de l’exercice, certains calculs ont été simplifiés.
Si Existe (T, N, Qui) = 1 alors
Erreur (« ce nom existe déjà)
Sinon Dans cet exercice, nous cherchons à simuler le calcul de l’impôt sur le revenu d’une famille
Répéter ayant des revenus salariés. Cette famille est caractérisée par le nombre d’adultes et le nombre
Ecrire « Début, Fin, ou après un autre (D,F,A) ?» d’enfants à charge. Les autres données prises en compte sont le salaire et les abattements.
Lire Mode Pour cela, on définit les fonctions ou procédures suivantes :
Jusqu’à (Mode = ‘D’ ou Mode = ‘F’ ou Mode = ‘A’
Si Mode = ‘D’ alors Insérer (T, N, Qui, 1) Fsi
Si Mode = ‘F’ alors Insérer (T, N, Qui, N+1) Fsi
1- Fonction qui calcule le revenu imposable RI
Si Mode = ‘A’ alors Pour cela, vous devez :
LireNom(Après, « Après Qui ? ») - Déduire du salaire 10 % pour frais professionnel (cet abattement est limité à un
Si Existe(T, N, Après) = 1 alors plafond de 77460F),
Insérer (T, N, Qui, Place(T, N, Après) - Ensuite déduire un abattement de 20 % (limité à un plafond de 141400F) pour
Sinon
Erreur (« Nom inconnu ») obtenir le revenu imposable.
Fsi 2- Fonction qui calcule le nombre de parts N qui est différent suivant qu’il s’agit d’une
Fsi famille à un seul adulte ou d’une famille ayant plus de deux enfants à charge. Pour un
Fsi adulte élevant seul ses enfants, les enfants comptent comme une part. Pour un couple
Fin
marié (adulte = 2) les deux premiers enfants comptent pour ½ part et au delà un enfant
Procédure rechercher (→tableau T[Nmax] : Chaîne de caractère, → N :
compte une part comme pour une personne seule.
numérique)
Variable Qui : chaîne de caractère Les deux fonctions précédentes servent à déterminer le quotient familial : QF = RI / N. Ce
Début quotient sert à déterminer la tranche d’imposition appropriée, de façon à appliquer la formule
LireNom(Qui, « Qui recherchez vous ? ») générale de calcul, qui est du type :
Si Existe(T, N, Qui) = 1 alors
Ecrire « Présent dans la liste » I = RI * Ti – Ki * N avec Ti et Ki donnés dans le tableau suivant.
Sinon
Ecrire « Inconnu dans la liste » Barème d’imposition pour la déclaration des revenus 1998
Fsi
Fin
Tranche Ti Abattement Ki
Procédure Supprimer ( ↔ tableau T[Nmax] : Chaîne de caractère, ↔ N : QF ≤ 26100 0 0
numérique) 26100 < QF ≤ 51340 0,105 2740,50
Variables Qui : Chaîne de caractères 51340 < QF ≤ 90370 0,24 9671,40
Variable i : numérique
Début 90370 < QF ≤ 146320 0,33 17804,70
LireNom(Qui, « Qui voulez vous supprimer ? ») 146320 < QF ≤ 238080 0,43 32436,70
Si Existe (T, N, Qui) = 1 alors 238080 < QF ≤ 293600 0,48 44340,70
N ← N – 1
Répéter pour i = Place (T, N, Qui) jusqu’à N faire QF > 293600 0,54 61956,70
T[i] ← T[i+1] 3- Procédure qui initialise un tableau (à deux dimensions) contenant le barème de
FinPour l’impôt
Sinon
 4- Dans le programme principal, les données sont lues pour calculer le quotient
familial. Il faut ensuite rechercher la tranche correspondant au barème puis on calcule
l’impôt suivant la formule décrite ci-dessus.

PROGRAM PIMPOT ;
Var Revenu, Impot : real ;
Adulte, Enfant, i: integer ;
Bareme : ARRAY[1..7, 1..4] of real ;
QF : real ;
PROCEDURE LIRE_BAREME ;
Var i, j : integer ;
BEGIN
FOR i := 1 TO 7 DO
FOR j := 1 TO 4 DO
BEGIN
Writeln('Entrer la valeur se trouvant en ligne ', i, ' et en colonne ', j);
READLN(Bareme[i,j]) ;
END;
END ;
{Remarque sur la structure du tableau : la première colonne contient la
borne inférieure, la deuxième la borne supérieure, la troisième Ti et la
quatrième Ki }

FUNCTION REVENU_IMPOSABLE : real ;

Var temp, C : real ;
BEGIN
temp := Revenu / 10 ; (* Abattement de 10% *)
IF temp <= 77460
THEN C := Revenu - temp
ELSE C := revenu - 77460 ;
temp := C * 2 / 10 ; (* Abattement de 20% *)
IF temp <= 141400
THEN REVENU_IMPOSABLE := revenu - temp
ELSE REVENU_IMPOSABLE := revenu - 141400 ;
END;

FUNCTION PARTS(Adulte, Enfant : integer) : real ;

BEGIN
IF Adulte = 1 THEN PARTS := Adulte + Enfant
ELSE IF (Enfant = 1) OR (Enfant =2)THEN PARTS:= Adulte + Enfant / 2
ELSE PARTS := Adulte + Enfant - 1 ;
END ;
{ Pour un couple marié (adulte = 2) les deux premiers enfants comptent pour
½ part et au delà un enfant compte une part
comme pour une personne seule. }

(* programme principal *)
BEGIN
LIRE_BAREME ;
writeln(' Entrez le nombre d''adultes et d''enfants : ');
READLN(Adulte, Enfant) ;
WRITELN('Entrez le revenu de la famille : ');
READLN(Revenu) ;
QF := REVENU_IMPOSABLE / PARTS(Adulte, Enfant);
i := 1 ;
WHILE (QF > Bareme[i,2]) DO
i := i + 1 ;
Impot := Bareme[i,3] * REVENU_IMPOSABLE ;
Impot := Impot - Bareme[i,4] * PARTS(Adulte, Enfant);
WRITELN('IMPOT = ', Impot) ;
READLN;
END.