Introduction à l'algorithmique ...

... Application au langage Pascal

(c) F. Bonnardot, Février 2005

 Qu'est ce qu'un algorithme ?
Définition :
Ensemble d'instructions qui permettent à une personne
ou à une machine d'obtenir à partir de données la solution
d'un problème en un nombre fini d'étapes.

Exemple :
Calcul des racines x1 et x2 d'un polynôme du second
ordre : ax2+bx+c dans R.

Algorithme : Racines
Coefficients
Calcul des racines d'un x et x
a, b et c
polynôme du 2nd ordre 1 2
 Comment obtenir les données ?
Indiquer les résultats ?
Algorithme : Racines
Coefficients
Calcul des racines d'un x et x
a, b et c
polynôme du 2nd ordre 1 2

Sorties :
Entrées :
Écran, Haut-parleur,
Clavier, Micro, Scanner,
Fichier sur disque,
Webcam, Fichier sur disque,
Imprimante, Variable en
Variable en mémoire, ... Ecran, clavier,
souris mémoire, ...
Unités de
Scanner stockage

Unité centrale
Imprimante
 Comment décrire l'algorithme ?
(1/2)
Langage machine :
Suite de nombres directement compréhensibles par l'ordinateur.
Assembleur :
Suite de commandes qui seront directement traduites en langage
machine.
program_init:
pushl %ebp Problèmes :
movl %esp,%ebp
subl $4,%esp Jeu d'instruction de l'ordinateur limité
movb
call
$1,U_SYSWIN32_ISCONSOLE
FPC_INITIALIZEUNITS
(beaucoup de texte à écrire)
.L4:
leal U_SYSWIN32_OUTPUT,%edi
movl %edi,-4(%ebp)
Instructions différentes d'un µP à l'autre
pushl .L9 (re-écrire pour chaque µP)
pushl -4(%ebp)
pushl $0
call FPC_WRITE_TEXT_ANSISTR Code difficile à lire
pushl -4(%ebp)
call FPC_WRITE_END
pushl
call
$.L4
FPC_IOCHECK
Avantage : rapidité, ...
 Comment décrire l'algorithme ?
(2/2)
Langages de haut niveau :
Langage proche du langage parlé (par les anglophones).
Program Chiffre;
{ Demande de saisir un chiffre et
Avantages :
recopie ce chiffre } Indépendant de l'ordinateur (+ ou -)
Var
(fonctionne sur PC, Mac, Unix, ...)
a : integer; { Chiffre lu }

Begin Lisibilité accrue

{ Demande du chiffre }
write ('Entrez un chiffre : ');
readln (a); Instructions « assez performantes »
{ Recopie le chiffre }
writeln ('Vous avez tapé ',a);
écriture sur l'écran, lecture de
End. texte, ...
On utilise un compilateur pour traduire le programme en langage machine.
Langage de Langage
Compilateur Exécutable
haut niveau machine
 Quel langage ?
Beaucoup de langages de programmation (Grafcet, Calculatrice, C++, ...)

On étudiera ici le Pascal

N.B. : Delphi permet de programmer windows en Pascal

Méthode :
1°) On écrit d'abord l'algorithme en Français (pseudo-langage)
=> On réfléchit (étape d'analyse)
2°) On le traduit ensuite en Pascal
=> On adapte pour un ordinateur et un langage

L'étape 1 est la plus difficile... => livres d'algorithmie

L'étape 2 est la plus facile => Livres d'apprentissage de Pascal, C++, ...
 Exemple : Racines d'un polynôme
du second ordre dans R (1/4)
Algorithme : Racines
Coefficients
Calcul des racines d'un x et x
a, b et c
polynôme du 2nd ordre 1 2

Analyse :
D'après le cours de maths de 1ère Étape 1 : Demander à l'utilisateur
de saisir a, b et c
On calcule ∆=b²-4ac
Étape 2 : Calcul de ∆
Si ∆<0 alors pas de racine dans R
Si ∆=0 alors racine double x=-b/(2a) Étape 3 : Selon ∆ calcul et affichage
Si ∆>0 alors deux racines : des racines
x1=-[b-sqrt(delta)]/(2a)
x2=-[b+sqrt(delta)]/(2a)
 Forme simplifiée d'un programme
Remplacer les < >
Programme <nom du programme>

Variables utilisées :
<nom de la variable 1> : <type>;
<nom de la variable 2>,<nom de la variable 3> : <type>
<etc...>

Début du programme
<Instruction 1>
<Instruction 2>
<etc ...>
Fin du programme
Program <nom_programme>;
En Pascal,
Pas d'accent ni Var
<nom 1> : <type>;
d'espace <nom 2>,<nom 3> : <type>;
pour les noms <etc...>;
et les instructions. Begin
Chiffres utilisables <Instruction 1>;
<Instruction 2>;
à partir du 2nd <etc ...>
caractère. End.
 Exemple : Racines d'un polynôme
du second ordre dans R (2/4)
Écriture en pseudo-langage :
Utilisation de 4 variables identifiées a, b, c et delta
Étape 1 : Demander à l'utilisateur Instruction : Écrire Écrire « Bonjour »
de saisir a, b et c Instruction : Lire Lire a, b, c

Étape 2 : Calcul de ∆ Affectation : delta <- b*b-4*a*c

Étape 3 : Selon ∆ calcul et affichage

des racines Instruction : Écrire Écrire « Delta= »,delta

Texte à écrire entre guillemets

Valeur de la variable delta : pas de guillemet
 Exemple : Racines d'un polynôme
du second ordre dans R (3/4)
Programme Racines Polynôme ordre 2 Nom du programme
Variables utilisées :
Nom des variables a,b,c,delta : nombres réels Type des variables
Début du programme
Écrire « Entrez les coefficients a, b, c »
Toute variable
Lire a, b, c utilisée doit être
déclarée (permet de
delta <- b*b-4*a*c détecter les fautes de
Test Si delta<0 Alors
frappe)
Écrire « delta<0, pas de solution dans R »
Sinon
Décalage pour Si delta=0 Alors
plus de lisibilité Écrire « Racine double : x1= »,-b/2/a
Sinon
Début
Écrire « delta>0, deux racines »
Écrire « x1= »,-(b-sqrt(delta))/2/a
Écrire « x2= »,-(b+sqrt(delta))/2/a
Fin
Fin du programme
 Exemple : Racines d'un polynôme
du second ordre dans R (4/4)
Programme Racines Polynôme ordre 2 Program RacPoly;

Variables utilisées : Var

a,b,c,delta : nombres réels a,b,c,delta : real;

Début du programme Begin

Écrire « Entrez les coefficients a, b, c » Write('Entrez les coefficients a, b, c');
Lire a, b, c Read (a, b, c);

delta <- b*b-4*a*c delta := b*b-4*a*c;

Si delta<0 Alors If delta<0 Then

Écrire « delta<0, pas de solution dans R » WriteLn ('delta<0, pas de solution dans R')
Sinon Else
Si delta=0 Alors If delta=0 Then
Écrire « Racine double : x1= »,-b/2/a WriteLn ('Racine double : x1= ',-b/2/a)
Sinon Else
Début Begin
Écrire « delta>0, deux racines » WriteLn ('delta>0, deux racines');
Écrire « x1= »,-(b-sqrt(delta))/2/a WriteLn ('x1= ',-(b-sqrt(delta))/2/a);
Écrire « x2= »,-(b+sqrt(delta))/2/a WriteLn ('x2= ',-(b+sqrt(delta))/2/a);
Fin End;
Fin du programme End.
Démonstration
 Quelques types de données
Entiers relatifs (-1, 54, ...) : Integer en Pascal
Étendue : -231 à 231-1 (µP 32 bits) ; -215 à 215-1 (16 bits)
Nombres 231=2 147 483 648 (231-1)+1=-231 215=32 768
Réels (-1.6e-4, 3.1415926...) : Real en Pascal
Étendue : 5.0E-324 à 1.7E308 sur µP 32 bits intel
Principe : -1.6e-4 => 2 entiers : -0.16 et -3
Logique Booléen (True ou False) : Boolean en Pascal
Texte 1 seul Caractère ('B') : Char en Pascal
Chaîne de caractères ('Bonjour') : String en Pascal
Vecteurs Tableau 1D ([5 8 2 5]) : Array [1..4] of Real
Matrices Tableau 2D ([[ 86 5
1
8
0
]) : Array [1..2,1..3] of Real
]

Exemple d'utilisation : voir page suivante ...

 Utilisation de différents types de
données en Pascal
Program Donnees;
{ Programme de démonstration des types de données }

{Variables utilisées }
Var
punit,ptot:real; (* prix unitaire, prix total *)
quantite :integer; (* quantité commandée *)
tva :real=0.206; (* tva *)
reference :string; (* référence produit *)

b:array [1..3] of real; (* vecteur à 3 éléments*)

c:array [1..3] of real=(1,5,9); (* vecteur à 3 éléments*)
A:array [1..2,1..3] of real; (* matrice 2x3 *)

Begin
punit:=1.30;
quantite:=3;
reference:='Stylo';

{ Calcul du prix total }

ptot:=quantite*punit;

{ Affiche le prix total }

writeln ('Prix total de ',reference,': ',ptot);

b [1]:=23;
A [2,1]:=9.9e3;
End.
 Comment commenter un
programme en Pascal
Program ResistanceCu;
{ Ce programme calcul la résistance d'un fil de cuivre à partir de sa longueur
et de la section }
{ Auteur : Frédéric Bonnardot }
Uses WinCrt; { Uniquement pour Turbo Pascal Windows de Borland }

Var
section, longueur : real; { nombres saisis par l'utilisateur }
resistance : real; { resistance du fil }

begin
{ Lecture de la section et de la longueur du fil }
write ('Section du fil de cuivre en mm2 : ');
readln (section);
write ('Longueur du fil de cuivre en m : ');
readln (longueur);

{ Calcul }
resistance:=1.7e-8*longueur/section/1e-6*1e3;

{ Affichage du résultat }
write ('La résistance du fil est : ',resistan[Link],' mohms');
end.
 Instructions
Les tests (si ... alors ...)
Si <condition> alors If <condition> Then
2 variantes : <instruction(s)> En Pascal : <instruction(s)>
Si <condition> alors If <condition> Then
<instruction(s)> En Pascal : <instruction(s)>
sinon Else
<instruction(s)> <instruction(s)>
<condition> :
(a=1 ou b≥2) et c≠1
s'écrit en Pascal
(a=1 or b>=2) and c<>1

1 seule <instruction>
instruction
<instruction(s)>
Début Begin
plusieurs <instruction> <instruction>;
<instruction> <instruction>;
instructions <...> <...>
Fin End
 Exemple de test
On demande un nombre et on indique si il est positif ou négatif
Etapes : 1) Demander le nombre
2) Selon le signe écrire positif ou négatif

Besoins : une variable pour ranger le nombre

Si on considère que 0 est positif : Sinon :
Programme Signe nombre v2
Programme Signe nombre Variables utilisées :
nombre : nombre entier
Variables utilisées :
nombre : nombre entier Début du programme
Écrire « Entrez un nombre : »
Début du programme
Écrire « Entrez un nombre : » Si nombre<0 alors
Lire nombre Écrire « Nombre négatif »
Sinon
Si nombre<0 alors Si nombre>0 alors
Écrire « Nombre négatif » Écrire « nombre positif »
Sinon Sinon
Écrire « nombre positif ou nul» Écrire « nombre nul »
Fin du programme Fin du programme
 Instructions
La sélection (selon ... faire)
Selon <variable de type entier ou caractère>
cas <valeur 1> faire <instruction(s)>
cas <valeur 2>,<valeur 3> faire <instruction(s)>
autres cas faire <instruction(s)> Facultatif
Fin selon

En Pascal :
Case <variable de type entier ou caractère> Of
<valeur 1> : <instruction(s)>;
<valeur 2>,<valeur 3> : <instruction(s)>;
Else <instruction(s)>
End

Exemple :
Case touche Of
'+' : WriteLn ('Somme : ',a+b);
'*' : WriteLn ('Produit : ',a*b);
Else WriteLn ('Touche inconnue.')
End
 Exemple d'utilisation de selon
On lit deux nombres et on affiche un menu pour demander à l'utilisateur
si il veut calculer la somme, le produit, le quotient de ces deux nombres.
Programme Opérations

Variables utilisées :
a,b : nombres réels
touche : caractère

Début du programme
{ Lecture des données}
Écrire « Saisir 2 nombres a et b »
Lire a,b

{ Affichage du menu }
Écrire « Pour calculer la somme, tapez + »
Écrire « Pour calculer le produit, tapez * »
Écrire « Pour calculer le quotient, tapez / »

touche <- touche enfoncée au clavier

{ Réaction selon cette touche }

Selon touche
cas '+' faire Écrire « La somme est »,a+b
cas '*' faire Écrire « Le produit est »,a*b
cas '/' faire Écrire « Le quotient est »,a/b
autres cas faire Écrire « Je n'ai pas compris ce que vous voulez faire »
Fin Selon

Fin du programme
 Instructions
Répétition (faire ... jusqu'à)
2 variantes : Faire Repeat
<instruction> <instruction>;
<instruction> En Pascal : <instruction>;
<...> <...>
Jusqu'à <condition> Until <condition>
Tant que <condition> faire While <condition> do
<instruction(s)> <instruction(s)>

En haut : on passe au moins une fois dans la boucle

En bas : si la condition n'est pas vérifiée au début, on n'exécute
aucune instruction
Exemple :
Repeat
WriteLn ('Entrer un nombre supérieur à 7 : ');
ReadLn (nombre)
Until nombre>7
 Exemples de répétitions
On demande un nombre supérieur à 7. Si l'utilisateur fait une erreur
on redemande ce nombre.

1er cas : 2ème cas : on indique à

l'utilisateur qu'il s'est trompé
Programme lire un nombre v2
Programme lire un nombre
Variables utilisées :
Variables utilisées :
nombre : réel
nombre : réel
Début du programme
Début du programme
Répéter
Écrire « Entrez un nombre >7 : »
Écrire « Entrez un nombre >7 : »
Lire nombre
Lire nombre
Jusqu'à ce que nombre>7
Tant que nombre<=7 faire
Début
Écrire nombre
Écrire nombre,« n'est pas>7, entrez un nombre >7 : »
Fin du programme
Lire nombre
Fin

Écrire nombre
Exécuté au moins 1 fois Fin du programme
Peut ne pas être éxécuté
 Instructions
Répétition n fois (pour . variant ...)
Pour <variable> variant de <début> à <fin> faire
<instruction(s)>

En Pascal :
For <variable>:=<début> to <fin> do Si fin<début, on utilisera
<instruction(s)> downto au lieu de to

Exemple :
moyenne:=0.;

For etudiant:=1 to 50 do
moyenne:=moyenne+note[etudiant];

moyenne:=moyenne/50;
 Exemple de Boucle
On désire calculer la norme d'un vecteur à 20 dimensions
Programme norme vecteur

Variables utilisées :
vecteur : tableau de 20 réels =(5,64.5,58,4,578,54,6.54,245,564,54,6.5,6,4,46,46,46,46.8,4.86,4,4.8)
position: entier
norme : réel

Début du programme
{ Initialise la norme }
norme <- 0

{ Pour chaque élément du vecteur }

Pour position variant de 1 à 20 faire
norme <- norme + vecteur [position]*vecteur [position]

norme <- racine carrée de norme

Écrire norme
Fin du programme
 Application au tri de données
On sait faire un tri à la main (trier un jeu de carte)
Mais on ne connait pas l'algorithme (cas général avec 1 million de cartes)...

1ère étape :
On prend des cartes et on regarde comment on fait à la main.

2ème étape :
On essaie d'écrire l'algorithme.
Règle du jeu :
On a dix cartes face cachées.
0.1€ pour retourner une carte.
Seules 2 cartes peuvent être retournées.

Il existe plusieurs méthodes de tri.

 Evaluation
Document autorisé : cours Pascal

Rendre la feuille à 8h15

1. A quoi servent les instructions writeln et readln.

2. Écrire en pseudo-langage (en français) un programme qui demande

de saisir à l'utilisateur 2 nombres a et b et qui indique le plus grand
des deux ainsi que l'écart entre ces deux nombres.