Introduction à l`algorithmique Application au langage Pascal

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
1
2
polynôme du 2nd ordre
Comment obtenir les données ?
Indiquer les résultats ?
Algorithme :
Racines
Coefficients
Calcul des racines d'un x et x
a, b et c
1
2
polynôme du 2nd ordre
Entrées :
Clavier, Micro, Scanner,
Webcam, Fichier sur disque,
Variable en mémoire, ...
Ecran, clavier,
souris
Unités de
stockage
Scanner
Unité centrale
Imprimante
Sorties :
Écran,
Haut-parleur,
Fichier
sur
disque,
Imprimante, Variable en
mémoire, ...
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
movl
%esp,%ebp
subl
$4,%esp
movb
$1,U_SYSWIN32_ISCONSOLE
call
FPC_INITIALIZEUNITS
.L4:
leal
U_SYSWIN32_OUTPUT,%edi
movl
%edi,-4(%ebp)
pushl
.L9
pushl
-4(%ebp)
pushl
$0
call
FPC_WRITE_TEXT_ANSISTR
pushl
-4(%ebp)
call
FPC_WRITE_END
pushl
$.L4
call
FPC_IOCHECK
Problèmes :
Jeu d'instruction de l'ordinateur limité
(beaucoup de texte à écrire)
Instructions différentes d'un µP à l'autre
(re-écrire pour chaque µP)
Code difficile à lire
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
recopie ce chiffre }
Var
Avantages :
Indépendant de l'ordinateur (+ ou -)
(fonctionne sur PC, Mac, Unix, ...)
a : integer; { Chiffre lu }
Begin
{ Demande du chiffre }
write ('Entrez un chiffre : ');
readln (a);
{ Recopie le chiffre }
writeln ('Vous avez tapé ',a);
End.
Lisibilité accrue
Instructions « assez performantes »
écriture sur l'écran, lecture de
texte, ...
On utilise un compilateur pour traduire le programme en langage machine.
Langage de
haut niveau
Compilateur
Langage
machine
Exécutable
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
1
2
polynôme du 2nd ordre
Analyse :
D'après le cours de maths de 1ère
On calcule ∆=b²-4ac
Si ∆<0 alors pas de racine dans R
Si ∆=0 alors racine double x=-b/(2a)
Si ∆>0 alors deux racines :
x1=-[b-sqrt(delta)]/(2a)
x2=-[b+sqrt(delta)]/(2a)
Étape 1 : Demander à l'utilisateur
de saisir a, b et c
Étape 2 : Calcul de ∆
Étape 3 : Selon ∆ calcul et affichage
des racines
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
En Pascal,
Pas d'accent ni
d'espace
pour les noms
et les instructions.
Chiffres utilisables
à partir du 2nd
caractère.
Program <nom_programme>;
Var
<nom 1> : <type>;
<nom 2>,<nom 3> : <type>;
<etc...>;
Begin
<Instruction 1>;
<Instruction 2>;
<etc ...>
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
de saisir a, b et c
Instruction : Écrire
Instruction : Lire
Écrire « Bonjour »
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)
Nom des variables
Programme Racines Polynôme ordre 2
Nom du programme
Variables utilisées :
a,b,c,delta : nombres réels
Type des variables
Début du programme
Écrire « Entrez les coefficients a, b, c »
Lire a, b, c
delta <- b*b-4*a*c
Test
Décalage pour
plus de lisibilité
Si delta<0 Alors
Écrire « delta<0, pas de solution dans R »
Sinon
Si delta=0 Alors
É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
Toute variable
utilisée doit être
déclarée (permet de
détecter les fautes de
frappe)
Exemple : Racines d'un polynôme
du second ordre dans R (4/4)
Programme Racines Polynôme ordre 2
Program RacPoly;
Variables utilisées :
a,b,c,delta : nombres réels
Var
Début du programme
Écrire « Entrez les coefficients a, b, c »
Lire a, b, c
Begin
Write('Entrez les coefficients a, b, c');
Read (a, b, c);
delta <- b*b-4*a*c
delta := b*b-4*a*c;
Si delta<0 Alors
Écrire « delta<0, pas de solution dans R »
Sinon
Si delta=0 Alors
É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
If delta<0 Then
WriteLn ('delta<0, pas de solution dans R')
Else
If delta=0 Then
WriteLn ('Racine double : x1= ',-b/2/a)
Else
Begin
WriteLn ('delta>0, deux racines');
WriteLn ('x1= ',-(b-sqrt(delta))/2/a);
WriteLn ('x2= ',-(b+sqrt(delta))/2/a);
End;
End.
a,b,c,delta : real;
Démonstration
Quelques types de données
Nombres
Entiers relatifs (-1, 54, ...) : Integer en Pascal
Étendue : -231 à 231-1 (µP 32 bits) ; -215 à 215-1 (16 bits)
231=2 147 483 648 (231-1)+1=-231
215=32 768
Logique
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
Booléen (True ou False) : Boolean en Pascal
Texte
1 seul Caractère ('B') : Char en Pascal
Vecteurs
Chaîne de caractères ('Bonjour') : String en Pascal
Tableau 1D ([5 8 2 5]) : Array [1..4] of Real
Matrices
Tableau 2D ([[ 86
5
1
]) : Array [1..2,1..3] of Real
8
]
0
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;
quantite :integer;
tva
:real=0.206;
reference :string;
(*
(*
(*
(*
prix unitaire, prix total *)
quantité commandée *)
tva *)
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 : ',resistance:6:1,' mohms');
end.
Instructions
Les tests (si ... alors ...)
2 variantes :
Si <condition> alors
<instruction(s)>
Si <condition> alors
<instruction(s)>
sinon
<instruction(s)>
En Pascal :
If <condition> Then
<instruction(s)>
En Pascal :
If <condition> Then
<instruction(s)>
Else
<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>
plusieurs
instructions
Début
<instruction>
<instruction>
<...>
Fin
<instruction(s)>
Begin
<instruction>;
<instruction>;
<...>
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
Début du programme
Écrire « Entrez un nombre : »
Lire nombre
Si nombre<0 alors
Écrire « Nombre négatif »
Sinon
Écrire « nombre positif ou nul»
Fin du programme
Variables utilisées :
nombre : nombre entier
Début du programme
Écrire « Entrez un nombre : »
Si nombre<0 alors
Écrire « Nombre négatif »
Sinon
Si nombre>0 alors
Écrire « nombre positif »
Sinon
Écrire « nombre nul »
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
<instruction>
<instruction>
<...>
Jusqu'à <condition>
En Pascal :
Tant que <condition> faire
<instruction(s)>
Repeat
<instruction>;
<instruction>;
<...>
Until <condition>
While <condition> do
<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.
2ème cas : on indique à
l'utilisateur qu'il s'est trompé
1er cas :
Programme lire un nombre
Variables utilisées :
nombre : réel
Début du programme
Répéter
Écrire « Entrez un nombre >7 : »
Lire nombre
Jusqu'à ce que nombre>7
Écrire nombre
Fin du programme
Exécuté au moins 1 fois
Programme lire un nombre v2
Variables utilisées :
nombre : réel
Début du programme
Écrire « Entrez un nombre >7 : »
Lire nombre
Tant que nombre<=7 faire
Début
Écrire nombre,« n'est pas>7, entrez un nombre >7 : »
Lire nombre
Fin
Écrire nombre
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
<instruction(s)>
Exemple :
moyenne:=0.;
For etudiant:=1 to 50 do
moyenne:=moyenne+note[etudiant];
moyenne:=moyenne/50;
Si fin<début, on utilisera
downto au lieu de to
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.