Introduction à l’algorithmique - info.univ-angers.frbasseur/Algo/introAlgo1314.pdf · 3 – Traduire cet algorithme en langage de programmation 4 ... En PASCAL, on ne tient pas

Introduction à l’algorithmique

L1 MPCIE

Équipe pédagogique e-mail Bureau

Vincent BARICHARD [email protected] H203

Matthieu BASSEUR [email protected] H205

Laurent GARCIA [email protected] H209

Adrien GOËFFON [email protected] H207

Frédéric LARDEUX [email protected] H208

Frédéric SAUBION [email protected] H213

Organisation du cours

Cours / TD : 35h

- 2 Cours d'1h20 par semaine

TP : 20h

- 9 TP de 2h + 1 contrôle TP, à partir du 23 septembre (bâtiment G, 1er étage)

- Apporter son cours en TP

- Se munir d'une clef USB pour sauvegarder votre travail à la fin de chaque TP

- Travail sur machine en dehors des TP conseillé

Évaluation

- 2 contrôles continus communs ("CCC") : CCC1 vers la Toussaint, CCC2 fin décembre 2013

- 1 contrôle continu TP ("CCTP") en décembre

- 1 note de TD ("CCTD") calculée à partir d'au moins deux contrôles continus TD

- Coefficients : CCC1 x3 ; CCC2 x3 ; CCTP x1 ; CCTD x2

Études en informatique à l'université d'Angers

Discipline informatique

Théorique

analyse numérique, théorie de l'information, théorie des langages, automates, …

Scientifique

résolution de problèmes complexes, bio-informatique, cryptologie, intelligence artificielle, …

Méthodologique

analyse, langages, génie logiciel, …

Technologique

composants, mémoires, périphériques, …

Systèmes

architecture, réseaux, systèmes d'exploitation, …

Applications

informatique de gestion, bureautique, conception assistée par ordinateur, automatique, robotique,

informatique médicale, GPS, internet, jeux vidéo, …

Discipline informatique

ENIAC, 1945 30 tonnes, 160 m² au sol, 5000 additions par seconde 2013

Algorithmique et programmation

Objectif du cours

Apprentissage de l'algorithmique des et méthodes de

programmation

Qu'est-ce qu'un algorithme

- suite finie d'opérations élémentaires permettant de

résoudre un problème donné

- vient du mathématicien et astronome perse

Muhammad ibn al-Khawarizmi, le père de l'algèbre, qui

formalisa au IXe siècle la notion d'algorithme

- l'algorithme le plus célèbre est l'algorithme d'Euclide

(vers 300 avant J.-C.) permettant de calculer le PGCD de

deux nombres dont on ne connait pas la factorisation

Étudions :

- le déroulement de l'algorithme d'Euclide avec 24 et 9

- l'écriture de l'algorithme d'Euclide en pseudo-code

- un algorithme déterminant si un nombre est premier

Algorithmique et programmation

Étapes de conception d'un programme informatique

1 – identifier le problème : quelle(s) donnée(s), quel(s) résultat(s) ?

2 – organiser les actions : écrire l'algorithme (pseudo-code, organigramme)

- réfléchir aux informations à manipuler

- analyser le problème et le décomposer éventuellement en sous-problèmes

- rendre l'algorithme compréhensible et efficace

- penser à l'utilisateur

3 – Traduire cet algorithme en langage de programmation

4 – Compiler le programme pour qu'il puisse être exécutable

Un langage de programmation permet à un humain d'écrire un code pouvant être analysé

par une machine puis transformé en un programme informatique.

Un programme informatique est une suite d'opérations prédéterminées pouvant être

exécutées par une machine.

PASCAL

Langage informatique utilisé en L1 : PASCAL

C, C++, JAVA sont probablement les principaux langages de programmation à connaitre pour un

informaticien et à apprendre lors d'un cursus informatique, mais :

- Le langage C est relativement technique et plus difficile à aborder lorsque les bases de

l'algorithmique ne sont pas connues

- C++ et JAVA sont des langages objet, faisant appel à un paradigme de programmation plus avancé

Le langage PASCAL est celui qui dispose de la syntaxe la plus claire et la plus proche du langage dit

"algorithmique", même s'il est bien moins puissant que le langage C. Il a été mis au point par Pr. Niklaus

Wirth dans les années 1970 dans un but pédagogique, et est en constante évolution depuis.

Tous les algorithmes que nous mettrons au point cette année pourront être écrits directement en

PASCAL.

Principaux langages étudiés au cours de la licence (parcours informatique)

L1 : PASCAL, SQL, HTML

L2 : C, JAVA, CAML, Javascript, PHP

L3 : C++, Assembleur

Variables et constantes

Une variable est un identificateur associant un nom à une valeur ou un objet.

Le nom d'une variable ne doit comporter que des lettres non accentuées, des chiffres (sauf en première

position) et des tirets bas. Il ne peut comporter d'espaces, de signes de ponctuation, de signes

arithmétiques ou de caractères spéciaux.

En PASCAL, on ne tient pas compte de la casse (majuscules / minuscules). Ce n'est pas le cas dans la

plupart des autres langages de programmation.

Une constante est une valeur définie au début du programme et qui reste

inchangée durant toute son exécution.

Les instructions de base

Une affectation est une opération (instruction) permettant d'attribuer une valeur à

une variable.

En PASCAL, elle est symbolisée par le signe :=

L'identifiant de la variable est à gauche du signe d'affectation.

La valeur ou plus généralement l'expression est à droite du signe d'affectation.

x := 5

y2 := y + 2 * z

i := i + 1

x prend la valeur 5 (au symbole x est désormais associé la valeur 5, jusqu'à ce que cette variable soit modifiée)

y + 2z donne y2 (l'expression y + 2*z est évaluée et sa valeur est "rangée" dans la variable de nom y2)

i prend pour valeur i+1 (i est actualisée : on ajoute 1 à la précédente valeur contenue dans la variable i)


readln(x)

readln(nom,prenom,age)

L'instruction basique de lecture interrompt le programme, attend que l'utilisateur

entre une valeur au clavier et stocke la valeur en mémoire dans la variable

désignée en paramètres.

En PASCAL : mot-clé readln suivi de la ou les variables entre parenthèses.

L'instruction basique d'écriture affiche le contenu de l'expression en paramètre.

Une expression peut être une valeur, le contenu d'une variable, le résultat d'un calcul, ou la concaténation

de plusieurs expressions.

En PASCAL : mot-clé write suivi de l'expression entre parenthèses, ou des expressions séparées par des

virgules. Une chaine de caractère doit être délimitée par des apostrophes.

Remplacer write par writeln permet de passer à la ligne après l'affichage.

writeln(19)

write('Bonjour le monde!')

write(age)

writeln('Je sais que 9*9 = ',9*9)

writeln()

Théoriquement, toute instruction de lecture doit être précédée d'une instruction d'écriture informative.


writeln('Programme évolué de voyance par ordinateur');

write('Déclinez l''identité de la personne (nom, prénom) : ');

readln(nom,prenom);

write('Quel est son âge : ');

readln(age);

write('En quelle année sommes nous ? ');

readln(annee);

writeln('Ce même jour en 2020, ',prenom,' ',nom,' aura ',2020 – annee + age,' ans')

En PASCAL, les instructions sont séparées par un délimiteur : le point-virgule

Les types de base

Un type définit les valeurs que peut prendre une donnée (en particulier une

variable) et les opérateurs qui peuvent lui être appliqués.

Types de base en programmation :

- Entiers : sous-ensemble de Z ; en PASCAL : integer

- Réels : sous-ensemble de D ; en PASCAL : real

- Booléens : deux valeurs possibles, vrai et faux ; en PASCAL : boolean (true / false)

- Caractères : lettres, chiffres, ponctuation… ; en PASCAL : char

En PASCAL, une valeur de type caractère doit être mentionnée entre apostrophes.

Opérateurs de calcul disponibles pour les types de base :

- Entiers : + ; – ; * ; div ; mod

- Réels : + ; – ; * ; /

- Booléens : and ; or ; not

Opérateurs de comparaison (le résultat est un booléen) :

- Entiers, réels, caractères : = ; <= ; < ; >= ; > ; <>

- Booléens : = ; <>

Connaitre les tables de vérité des opérateurs booléens

Premier programme PASCAL

program Calcul_TVA ;

var prixTTC, tauxTVA : real ;

begin

write('Quel est le prix TTC ? ') ;

readln(prixTTC) ;

write('Quel taux de TVA s'applique en % ? ') ;

readln(tauxTVA) ;

tauxTVA := tauxTVA / 100 ;

writeln('Le prix HT est de ',prixTTC * (1 – tauxTVA)) ;

writeln('Le montant de la TVA est de ',prixTTC * tauxTVA)

end.

Un programme PASCAL débute par le mot-clé program suivi du nom du programme. Ce nom ne doit plus

être réutilisé dans la suite du programme.

Toutes les constantes utilisées dans le programme, et les variables utilisées dans le programme principal doivent être déclarées auparavant. La déclaration des constantes est initiée par le mot-clé const. La

déclaration des variables est initiée par le mot-clé var. Le type de chaque variable doit être précisé lors de

la déclaration. Les constantes ne sont pas typées.

Le corps du programme principal débute par le mot-clé begin et termine par end suivi d'un point.










begin


readln(prixTTC) ;


readln(tauxTVA) ;


writeln('Le prix HT est de ',(prixTTC * (1 – tauxTVA)):5:2) ;

writeln('Le montant de la TVA est de ',(prixTTC * tauxTVA):5:2)

end.

Avec un meilleur affichage

Nombre minimal de caractères affichés

(avec alignement à droite)

Précision de l'arrondi

(chiffres après la virgule)










begin


readln(prixTTC) ;


readln(tauxTVA) ;




end.

La présentation du code est importante.

La plupart des espaces (hormis celles

séparant les mots-clés, variables ou

valeurs), les tabulations et les sauts de

ligne n'ont aucun effet sur le programme

mais sont indispensables pour la lisibilité

du code.









const tauxTVA = 0.196 ;

var prixTTC, : real ;

begin


readln(prixTTC) ;



end.

Version avec TVA connue









const tauxTVA = 0.196 ; // On fixe la TVA à 19,6%

var prixTTC, : real ;

{Début du programme principal}

begin


readln(prixTTC) ;



end.

Avec commentaires

Commentaire de fin de ligne

Bloc de commentaire

La conditionnelle

Les instructions d’affectation, de lecture et d’écriture sont des instructions séquentielles.

Une instruction conditionnelle permet d’exécuter ou non un bloc d’instructions selon le

résultat d’un test (choix binaire).

if <condition> then <instruction1> else <instruction2>

if <condition> then <instruction1>

if <condition> then

begin

<instruction1> ;

<instruction2>

end

else <instruction3>

Bloc d’instructions

Un bloc d’instructions (suite d’instructions séparées par des points-virgules et encadrées par begin et end) peut remplacer une simple instruction.

Conditionnelle complète (if… then…else)

Conditionnelle incomplète (if… then)

Si la condition est vérifiée, alors on exécute l’instruction 1 [sinon on ne fait rien]

Si la condition est vérifiée, alors on exécute l’instruction 1, sinon on exécute l’instruction 2

La conditionnelle

Comme une conditionnelle est elle-même une instruction, il peut y avoir une ou plusieurs

conditionnelles à l’intérieur d’une conditionnelle. On parle de conditionnelles imbriquées.

if <condition1> then

if <condition2> then <instruction1>

else <instruction2>

else <instruction3>

En PASCAL, le point-virgule est un séparateur d’instructions. Il ne faut donc jamais mettre un point-virgule juste devant le mot-clé else.

Une condition est une expression booléenne, dont la valeur est soit vraie, soit fausse.

X

not X

X = true

X = false

(note >= 0) and (note <= 20)

not ((note >=0) and (note<=20))

(note < 0) or (note > 20)

(i < valeurMax) and (not trouve)

Programmes à écrire :

1 – Parité d’un nombre

2 – Calcul booléen avec l’opérateur XOR

Une condition peut-être de la forme : (<condition1>) <and/or> (<condition2>)

not (<condition>)

La conditionnelle

Il faut éviter d’imbriquer un trop grand nombre de conditionnelles (problèmes de lisibilité à

partir de 3 / 4 niveaux.

L’instruction case…of permet d’éviter certaines imbrications de conditionnelles, et permet de

traiter directement des choix qui ne sont plus binaires. Elle est réservée à des conditions bien

précises (égalité variable - constantes).

case <variable> of

<ensembleDeValeurs1> : <instruction1> ;

<ensembleDeValeurs2> : <instruction2> ;

…

<ensembleDeValeursN> : <instructionN>

else <instruction0>

end

- un ensemble de valeurs est une valeur constante, ou plusieurs valeurs constantes séparées par des virgules

- le else est facultatif

- chaque instruction peut être un bloc d’instructions

Exercice : écrire un programme qui donne le nombre de jours dans un mois.

La conditionnelle

program appreciation_automatique ;

var note : integer ;

begin

writeln(’Quelle est la note obtenue ? ’) ;

readln(note) ;

case note of

20 : writeln(’Parfait !’) ;

18,19 : writeln(’Excellent’) ;

16,17 : writeln(’Très bien’) ;

14,15 : writeln(’Bien’) ;

10..13 : writeln(’Passable’) ;

0..9 : begin

writeln(’Insuffisant’) ;

writeln(’Il aurait fallu travailler !’)

end

else writeln(’Note invalide’)

end

end.

Instruction répétitive

Une boucle permet d’effectuer un traitement à plusieurs reprises.

Il existe plusieurs types de boucles :

- la boucle TANT QUE

- la boucle REPETER (ou boucle JUSQU’À CE QUE)

- la boucle POUR (extension de la boucle TANT QUE)

Principe de la boucle TANT QUE :

TANT QUE la condition est vraie :

- on effectue l’instruction (ou le bloc d’instructions)

- on revient au début de la boucle

Lorsque la condition est fausse, on passe à l’instruction suivante.

while <condition> do <instruction>

while <condition> do

begin

<instruction1> ;

<instruction2>

end

Instruction répétitive

program tours_de_boucle ;

var n : integer ;

begin

n := 0 ;

while n < 3 do

begin

writeln('Un tour... ') ;

n := n + 1

end ;

writeln('Fini !')

end.

Exercices :

1 – Quel est l’affichage produit par le programme tours_de_boucle ?

2 – Écrire l’algorithme d’Euclide en PASCAL (pgcd de deux nombres entiers)

Tableaux

Un tableau est une structure de données regroupant un ensemble de variables de

même type.

5 0 2 19 -5 2 1 8

T[1] T[2] T[3] T[4] T[5] T[6] T[7] T[8]

Exemple de tableau d’entiers de dimension 8, indicé de 1 à 8

La variable T est de type tableau d’entiers indicé de 1 à 8.

On accède aux valeurs du tableau par T[1], T[2], …, T[8].

L’indice doit être une expression entière (constante, variable, calcul).

Tableaux

type <NomType> = <typeStructuré>;

type TabEntier = array [1..8] of integer;

var T1, T2 : TabEntier;

Déclaration d’un type structuré :

Syntaxe :

Exemple :

var <NomVar> : array [<const1>..<const2>] of <type>;

Déclaration d’une variable de type tableau :

Syntaxe :

Cette syntaxe est fonctionnelle mais déconseillée dans le cas général.

Lors de l’utilisation de types structurés comme des tableaux, il est préférable de commencer

par définir le type lui-même (par exemple : type tableau d’entiers indicé de 1 à 8).

On pourra alors utiliser plusieurs variables correspondant à ce même type.

Tableaux

T[i+1]:=5

readln(T[3])

writeln(’La ’,x,’e valeur est ’,T[x])

if T[T[1]+T[2]] = T[1] + T[2] then writeln(’coup de chance’)

Utilisation d’un tableau :

Chaque T[i] se comporte comme une variable classique.

Les instructions de lecture, écriture peuvent s’appliquer à chacun des éléments mais pas au

tableau tout entier.

Il faut saisir ou afficher les éléments un par un, en utilisant une boucle.

readln(T) writeln(T)

Tableaux

program reaffichage;

const Nmax=100; {limite de taille du tableau}

type Tent = array[1..Nmax] of integer; {déclaration du type Tent}

var T : Tent; {le tableau}

n : integer; {nombre d’éléments à saisir}

i : integer; {indice pour parcourir le tableau}

begin

write(’Combien de valeurs (<’,Nmax,’) ? ’);

readln(n);

i:=1;

while i<=n do

begin

write(’Donner le ’,i,’eme element: ’);

readln(T[i]);

i:=i+1

end

writeln(’Vous venez de saisir les valeurs suivantes : ’);

i:=1;

while i<=n do

begin

write(T[i],’ ’);

i:=i+1

end

end.

Tableaux

program reaffichage;

const Nmax=100; {limite de taille du tableau}

type Tent = array[1..Nmax] of integer; {déclaration du type Tent}

var T : Tent; {le tableau}

n : integer; {nombre d’éléments à saisir}

i : integer; {indice pour parcourir le tableau}

begin

write(’Combien de valeurs (<’,Nmax,’) ? ’);

readln(n);

i:=1;

while i<=n do

begin

write(’Donner le ’,i,’eme element: ’);

readln(T[i]);

i:=i+1

end

writeln(’Vous venez de saisir les valeurs suivantes : ’);

i:=1;

while i<=n do

begin

write(T[i],’ ’);

i:=i+1

end

end.

La taille du tableau est constante

La taille utile du tableau peut varier

Tableaux à deux dimensions

program saisie_matrice;

const Lmax=100; Cmax=100;

type matrice = array[1..Lmax,1..Cmax] of real;

var M : matrice;

n1,n2 : integer;

i,j : integer;

begin

write(’Combien de lignes (<’,Lmax,’) ? ’);

readln(n1);

write(’Combien de colonnes (<’,Cmax,’) ? ’);

readln(n2);

i:=1;

while i<=n1 do

begin

j:=1;

while j<=n2 do

begin

write(’Donner l’’element [’,i,’,’,j,’] : ’);

readln(M[i,j]);

j:=j+1

end;

i:=i+1

end

{...traitement éventuel sur les données}

end.

Chaines de caractères

Une chaine de caractère (en anglais : string) est un type structuré similaire à un

tableau de caractères, et représentant une suite de caractères.

Il est prédéfini dans la plupart des langages de programmation et associé à des fonctions

spécifiques qui permettent de les manipuler plus simplement.

B o n j o u r

S[1] S[2] S[3] S[4] S[5] S[6] S[7]

var <NomVar> : string Déclaration :

Le nombre de caractères d’une chaine est accessible via la fonction length(<NomVar>).

Elle représente sa taille utile. D’autres fonctions permettant de manipuler les chaines seront vues plus tard.

Contrairement aux tableaux, les chaines de caractères peuvent être lues et affichées au même

titre que les caractères qui les composent.

var <NomVar> : string[<const2>]

s

La taille n’est pas précisée

(valeur par défaut : 255 caractères)

La taille maximale de la chaine est précisée

length(S) = 7

Chaines de caractères

program exemple_chaines;

var s,nom : string;

tel : string[10];

begin

write(’Comment vous appelez-vous ?’);

readln(nom);

s := ’Bonjour’;

writeln(s,’ ’,nom);

writeln(’L’’initiale de votre nom est ’,nom[1]);

writeln(’Votre nom est composé de ’,length(nom),’ lettres’)

writeln(’Entrez votre numéro de téléphone’);

readln(tel);

{…}

end.

Opérations de base sur les chaines :

Concaténation : ‘Bon’ + ‘jour’ ‘Bonjour’

Comparaison : ‘Un’ < ‘Deux’ false Tous les opérateurs de comparaison habituels sont disponibles : < ; > ; <= ; >= ; = ; <>

Instruction répétitive (2)

Rappels sur la boucle TANT QUE : while <condition> do <traitement>

• La condition doit finir par devenir fausse (on répète le traitement tant que la condition est vraie)

• Si la condition est fausse à la première exécution, le traitement n’est jamais réalisé.

La boucle RÉPÉTER : repeat <traitement> until <condition>

• En PASCAL, la boucle RÉPÉTER est de type RÉPÉTER…JUSQU’À

• La condition doit finir par devenir vraie (on répète le traitement jusqu’à ce que la condition soit vraie, i.e. tant

que la condition est fausse)

• Le traitement est réalisé au moins une fois, car le test est effectué après.

repeat

writeln(’saisir la note’);

readln(note)

until (note >= 0) and (note <= 20)

Remarque : pas de begin/end car le bloc d’instructions à répéter est déjà encadré par repeat et until.


repeat

<traitement>

until <condition>

Propriété : TANT QUE et RÉPÉTER ont le même pouvoir expressif.

Preuve :

varbool := false;

while not varbool do

begin

<traitement>

varbool := <condition>

end

while <condition> do

<traitement>

if <condition> then

repeat

<traitement>

until not <condition>


La boucle POUR (for)

La boucle POUR permet d’effectuer un traitement à plusieurs reprises en incrémentant ou décrémentant

automatiquement une variable entière.

sommeChiffres := 0;

for i := 1 to 9 do

sommeChiffres := sommeChiffres + i;

for <nomVarBoucle> := <exprInf> to <exprSup> do

<traitement>

for <nomVarBoucle> := <exprSup> downto <exprInf> do

<traitement>

sommeChiffres := 0;

for i := 9 downto 1 do

sommeChiffres := sommeChiffres + i;

• <nomVarBoucle> est une variable de type entier (integer) qui ne doit théoriquement jamais

être modifiée dans le traitement. • <exprInf> et <exprSup> sont des expressions entières (variables, constantes, résultats d‘un calcul).

• <traitement> est une instruction ou une suite d’instructions séparées par begin / end.

Boucle POUR croissante

Boucle POUR décroissante


Une boucle POUR croissante (for...to...do) exécute un traitement pour chaque valeur entière comprise

entre deux bornes, dans l’ordre croissant (la variable de boucle prend successivement chacune de ces

valeurs). for i:=1 to 5 do

write(i,' ') 1 2 3 4 5

Une boucle POUR décroissante (for...downto...do) fait la même chose dans l’ordre inverse (la variable de

boucle prend successivement chaque valeur de l’intervalle dans l’ordre décroissant).

Une boucle POUR est un cas particulier d'une boucle TANT QUE :

for i:= MIN to MAX do

<traitement>

i:= MIN;

while (i<=MAX) do

begin

<traitement>;

i:=i+1

end;

i:=i-1

for i:=5 downto 1 do

write(i,' ') 5 4 3 2 1

Quelques cas particuliers :

for i:= N1 to N2 do

<traitement>

Si N1 = N2, une seule itération avec i=N1

Si N1 > N2, aucune itération (mais correct)

for i:= N1 downto N2 do

<traitement>

Si N1 = N2, une seule itération avec i=N1

Si N1 < N2, aucune itération (mais correct)


program sommeEntiers;

var n,i,somme : integer;

begin

writeln('Somme des n premiers entiers');

repeat

writeln('Entrez n (> 0)');

readln(n)

until n > 0;

somme:=0;

for i:=1 to n do

somme:=somme+i;

writeln('La somme des ',n,' premiers entiers est ',somme)

end.


program minTableau;

const TAILLEMAX = 1000;

type tabEntiers = array[1..TAILLEMAX] of integer;

var n, i, min : integer;

T : tabEntiers;

begin

{Saisie des valeurs}

repeat

writeln('Combien de valeurs à saisir ? (entre 1 et ',TAILLEMAX,')');

readln(n)

until (n >= 1) and (n <= TAILLEMAX);

for i:=1 to n do

readln(T[i]);

{Calcul puis affichage du minimum}

min:=T[1];

for i:=2 to n do

if min > T[i] then min:=T[i];

writeln('Valeur minimum : ',min)

end.

Sous-programmes

Un langage possède un nombre d’instructions limitées.

Comment créer de nouvelles instructions ?

La plupart des problèmes sont compliqués à résoudre et nécessitent d’être décomposés en

sous-problèmes.

Comment définir et utiliser des sous-programmes permettant de résoudre des sous-

problèmes ?

Un sous-programme est un bloc d’instructions séparé du bloc principal permettant de résoudre

un sous-problème. On peut appeler un sous-programme dans le programme principal ou dans

un autre sous-programme.

Décomposition

Pour résoudre un problème, on isole chaque sous-problème en déterminant ses entrées (données)

et ses sorties (résultats).

Un sous-problème est un problème et peut être décomposé. Un sous-programme peut donc utiliser

d’autres sous-programmes.

Sous-programmes

Déclaration d’un sous-programme

En PASCAL, la déclaration d’un sous-programme comprend :

• sa catégorie (fonction ou procédure)

• son nom

• ses paramètres formels

Elle est suivie par la déclaration de ses variables locales et un bloc d’instructions.

Les variables locales déclarées dans un sous-programme ne sont pas visibles hors du sous-

programme.

Appel / exécution d’un sous-programme

Un sous-programme est exécuté par le programme principal ou un autre sous-programme par appel

de son nom et de ses paramètres effectifs.

Sous-programmes

Nature des paramètres

Une donnée est une valeur transmise au sous-programme et utilisée par celui-ci. Une donnée

n’est jamais modifiée par le sous-programme.

Un résultat est une valeur que le sous-programme transmet au programme ou sous-programme

qui l’appelle.

Une donnée modifiée est à la fois donnée et résultat. Il s’agit d’une donnée que le sous-

programme peut modifier dans le but d’être retransmise au programme qui l’appelle.

Les paramètres résultats et données modifiées sont des variables, non initialisées (résultats) ou

initialisées (données modifiées).

Catégories de sous-programmes

Une fonction : sous-programme typé qui retourne un résultat à partir d’un certain nombre de

données (pas de données modifiées ni de paramètre résultat qui peut-être considéré comme la

fonction elle-même).

Une procédure : sous-programme non typé qui utilise un nombre libre de données, résultats et

données modifiées, mais ne retourne pas à proprement parler un résultat.

Sous-programmes : fonctions

Une fonction calcule une valeur à partir de 0, 1 ou plusieurs données en paramètre.

function nomFonction(donnee1:type1; donnee2:type2; … ; donneeN:typeN):typeResultat;

var …; {déclaration des variables locales}

begin

… {bloc d’instructions}

end;

Les paramètres sont uniquement des données, et le résultat n’est pas considéré comme un

paramètre.

Pour retourner un résultat, la fonction doit contenir au moins une instruction de type nomFonction:=…;

En PASCAL, dans le bloc d’instruction de la fonction, le nom de la fonction s’utilise comme une

variable du type de la fonction..

Déclaration d’une fonction.


• une fonction appelée doit être préalablement déclarée

• une fonction doit être appelée à l’intérieur d’une instruction (elle ne constitue pas une instruction en tant que telle). Par exemple : x := mafonction(a,b,c) avec x du même type que

mafonction(p1,p2,p3) et le ième paramètre effectif même type que le ième paramètre formel de

la fonction.

Lors de l’appel, la fonction s’exécute avec comme paramètres (données) les valeurs des

paramètres effectifs.

Après exécution de la fonction, sa valeur calculée (résultat) remplace l’appel de la fonction dans

l’instruction où elle a été effectuée. L’appel d’une fonction correspond à une expression dont on

évalue la valeur.

Appel d’une fonction (dans un autre bloc d’instructions)

… nomFonction(val1,val2,…,valN)…;


program testmin;

function min(x: integer; y: integer):integer;

begin

if x<y then min:=x

else min:=y;

end;

var a, b: integer;

begin

write(‘Entrer deux valeurs: ’);

readln(a);

readln(b);

writeln(‘Le min est : ’,min(a,b));

end.


Important

• L’ordre des paramètres doit être bien respecté lors de l’appel de la fonction

• On ne modifie jamais les paramètres dans une fonction

• Il n’y a pas de lecture des données dans la fonction ; elles sont passées en paramètres

• Il n’y a pas à afficher le résultat dans la fonction

Attention à la distinction entre paramètres formels et paramètres effectifs

Paramètres formels lors de la déclaration :

f : N N

f(x) = x²

Paramètres effectifs lors de l’exécution :

f(3)

f(a) avec a=5

f(x) avec x=1

Sous-programmes : procédures

Une procédure peut être considérée comme une fonction ne renvoyant pas de valeur.

En PASCAL, des paramètres peuvent être modifiés uniquement dans des procédures (données

modifiées et résultats). Une procédure peut également avoir des données en paramètres, non

modifiables.

L'appel à une procédure est une instruction en tant que telle.

procedure nomProc(param1:type1; var param2:type2; …);

var …; {déclaration des variables locales}

begin

… {bloc d’instructions}

end;

Les paramètres peuvent être des données, des données modifiées ou des résultats. Les données modifiées et résultats sont précédés par le mot-clé var.

Une procédure n'a pas de type associé. Il ne doit jamais y avoir d'instruction du genre nomProc:=…;

Déclaration d’une procédure


• une procédure appelée doit être préalablement déclarée

• les données en paramètres doivent être des expressions (valeur, variable, résultat d'un calcul ou

d'une fonction) correspondant aux types déclarés • les données modifiées et résultats (var lors de la déclaration, mais pas lors de l'appel)

correspond obligatoirement à une variable correspondant au type déclaré

• l'ordre des paramètres doit être bien respecté lors de l'appel de la procédure

Appel d’une procédure (dans un autre bloc d’instructions)

nomProc(val1,val2,…);


program testajoute;

procedure ajoute(var x: integer; y: integer);

begin

x := x+y;

end;

var a, b: integer

begin

readln(a);

readln(b);

ajoute(a, b);

writeln(a, b);

end.

Sous-programmes : synthèse

• des données doivent être modifiées : PROCÉDURE

• des données vont être saisies ou modifiées : PROCÉDURE

• un ensemble de résultats va être produit : PROCÉDURE

• calculer un résultat à partir d'un ensemble de données : FONCTION

• pouvoir utiliser le sous-programme dans une expression : FONCTION

Procédure ou fonction ?

Décomposition

Les sous-programmes permettent de séparer des tâches indépendantes.

Il faut en particulier séparer les interactions avec l'utilisateur des opérations de calcul. Un

sous-programme qui réalise un calcul pour produire un ou plusieurs résultats n'a pas à interagir

avec l'utilisateur pour lui demander des informations. Un sous-programme réalise un traitement à

partir de ses paramètres, et non sur des valeurs demandées à l'utilisateur. La demande

d'information ou l'affichage des résultats se fera dans des sous-programmes dédiés.

Réutilisation

Les sous-programmes peuvent être utilisés plusieurs fois au cours de l'exécution du programme,

ou même jamais.

Sous-programmes : exemple

On souhaite réaliser un programme calculant, à partir des relevés de températures sur une

semaine de deux villes, laquelle a la température moyenne la plus élevée.

Températures hebdomadaires

Définir un type permettant de stocker les températures hebdomadaires d'une ville

Écrire un sous-programme calculant la moyenne des températures de la semaine

Écrire un sous-programme permettant la saisie des températures hebdomadaires d'une ville

Écrire un sous-programme déterminant, parmi deux villes, celle qui a la température moyenne

la plus élevée

Écrire le programme principal permettant de réaliser les traitements


Définir un type permettant de stocker les températures hebdomadaires d'une ville

const NBJOURS=7;

type TableauTemp=array[1..NBJOURS] of real;


Écrire un sous-programme calculant la moyenne des températures de la semaine

function moyenne(t: TableauTemp): real;

var somme: real; i: integer;

begin

somme := 0;

i := 1;

while i<= NBJOURS do

begin

somme := somme + t[i];

i := i+1;

end;

moyenne := somme / NBJOURS;

end;


Écrire un sous-programme permettant la saisie des températures hebdomadaires d'une ville

procedure saisie(var t: TableauTemp);

var i: integer;

begin

for i:=1 to NBJOURS do

begin

writeln(’Temperature de ’,jour(i));

readln(t[i])

end

end;

function jour(j:integer):string;

begin

case j of

1: jour:='dimanche';

2: jour:='lundi';

3: jour:='mardi';

4: jour:='mercredi';

5: jour:='jeudi';

6: jour:='vendredi';

7: jour:='samedi'

end

end;


Écrire un sous-programme déterminant, parmi deux villes, celle qui a la température moyenne

la plus élevée

function moyennePlusElevee(v1: string; t1: TableauTemp; v2: string;

t2: TableauTemp): string;

begin

if moyenne(t1) > moyenne(t2)

then moyennePlusElevee := v1

else moyennePlusElevee := v2;

end;


Écrire le programme principal permettant de réaliser les traitements

var t1, t2: TableauTemp;

v1, v2: string;

begin

writeln(’Ville 1’);

readln(v1);

saisie(t1);

writeln(’Ville 2’);

readln(v2);

saisie(t2);

write(moyennePlusElevee(v1,t1,v2,t2),’ a une temperature plus elevee’);

end.

Pour représenter un nombre entier naturel, il faut disposer de symboles appelés chiffres.

Tout nombre entier N peut être exprimé dans la base b à l’aide de b chiffres distincts allant de 0 à b-1 sous la

forme :

1

0

k

i

i

ib baN , où chaque ai est un chiffre.

k est un nombre de chiffres suffisant pour écrire N dans la base b.

Dans la base b, N s’écrit ak-1ak-2…a1a0.

Compter en base 2 : 0, 1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100, …

Compter en base 3 : 0, 1, 2, 10, 11, 12, 20, 21, 22, 100, 101, 102, 110, 111, 112, 120, …

Compter en base 10 : 0, 1, 2, 3, …, 9, 10, 11, 12, 13, …, 99, 100, 101, 102, 103, …

Compter en base 16 : 0, 1, 2, …, 9, A, B, C, D, E, F, 10, 11, 12, …, 1F, 20, 21, …, FF, 100, …

197510 = 1 x 1000 + 9 x 100 + 7 x 10 + 5 = 1 x 103 + 9 x 102 + 7 x 101 + 5 x 100

chiffres {0, …, 9}

Annexe : Conversion binaire / décimal

Conversion d’un nombre de la base 2 vers la base 10 (binaire décimal) :

110012 = 1 x 24 + 1 x 23 + 0 x 22 + 0 x 21 + 1 x 20 = 1610 + 810 + 110 = 2510

Table des puissances de 2

20 21 22 23 24 25 26 27 28 29 210 211 212 213 214 215

1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768

Conversion d’un nombre de la base 10 vers la base 2 (décimal binaire) :

Il suffit d’effectuer des divisions euclidiennes successives du nombre par 2, et d’écrire les restes dans l’ordre inverse.

13 2

1 6 2

0 3 2

1 1 2

1 0



110012 = 1 x 24 + 1 x 23 + 0 x 22 + 0 x 21 + 1 x 20 = 1610 + 810 + 110 = 2510


20 21 22 23 24 25 26 27 28 29 210 211 212 213 214 215

1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768



13 2

1 6 2

0 3 2

1 1 2

1 0

1310 = 11012 (= 8+4+1)

somme de

puissances de 2



110012 = 1 x 24 + 1 x 23 + 0 x 22 + 0 x 21 + 1 x 20 = 1610 + 810 + 110 = 2510


20 21 22 23 24 25 26 27 28 29 210 211 212 213 214 215

1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768



13 2

1 6 2

0 3 2

1 1 2

1 0

1310 = 11012 (= 8+4+1)

N Q R

167 83 1

83 41 1

41 20 1

20 10 0

10 5 0

5 2 1

2 1 0

1 0 1

16710 = 101001112 (= 128+32+4+2+1)

Le chiffre (bit en base 2) le plus significatif est le

reste de la dernière division.

Le chiffre (bit) le moins significatif est le reste de

la première division.

somme de

puissances de 2


Documents

Introduction à l’algorithmique - info.univ-angers.frbasseur/Algo/introAlgo1314.pdf · 3 – Traduire cet algorithme en langage de programmation 4 ... En PASCAL, on ne tient pas