Algorithmique et langage Pascal

COURS
Lycée Dominique Villars
ECE 1
ALGORITHMIQUE et LANGAGE PASCAL
1
Notion d’algorthme
Certains voient à tort, dans l’ordinateur une machine ”pensante”, capable de résoudre bien des problèmes. En
réalité, celui-ci ne serait capable de rien si quelqu’un (le programmeur) ne lui avait fourni la liste des actions à
exécuter.
Cette desciption doit être faite de manière non ambigüe et dans un ordre bien choisi. Il ne faut s’attendre à aucune
interprétation des ordres fournis. L’ordinateur exécutera ces actions de manière purement mécanique.
Le problème principal du programmeur est donc de décrire la suite des actions élémentaires permettant d’obtenir
à partir des données fournies, les résultats escomptés. Cette description doit à la fois la plus simple (niveau de
complexité d’un programme) et précise possible.
Cette marche à suivre porte le nom d’algorithme. Cette notion est totalement indépendante de l’informatique.
En effet, une recette de cuisine est un algorithme, tout comme une notice de montage de meubles suédois. . .
Dans le contexte informatique, un algorithme doit être traduit dans un langage qui permettra à l’ordinateur de
comprendre chacune des instructions élémentaires. Cette année nous traduirons chacun des algorithmes étudiés
dans le langage Turbo-Pascal.
Exemple principal : Calcul d’une puissance : (1, 7)64
La valeur (1, 7)64 peut être obtenue par la mise en oeuvre d’un algorithme 1 dont on peut proposer la description
suivante :
① Calcul du produit 1, 7 × 1, 7 dont la valeur est stocké comme résultat intermédiaire, noté A1 .
② Calcul de 1, 7 × A1 dont la valeur est stocké comme résultat intermédiaire, noté A2 .
③ Répéter 61 fois cette dernière opération ;
④ La valeur cherchée est le dernier résultat intermédiaire.
Pour un même ”travail”, il est possible de faire appel à d’autres algorithmes. Par exemple, on peut décrire
l’algorithme 2 par :
① Calculer le produit 1, 7 × 1, 7 dont la valeur est stocké comme résultat intermédiaire,B1 .
② Calculer le produit B1 × B1 dont la valeur est un nouveau résultat intermédiaire B2 . (B2 = (1, 7)4 )
③ Répéter 4 fois cette opération.
④ La valeur cherchée est B6 dernier résultat intermédiaire calculé.
Structure générale d’un algorithme :
A l’image d’une recette de cuisine, l’algorithme de décompose en trois parties :
1. On énumère tous les ingrédients =⇒ on liste toutes les donnés nécessaires, les entrées .
2. On décrit les étapes successives =⇒ on énumère les instructions que l’ordinateur doit exécuter.
3. Si les étapes 1 et 2. sont cohérentes, le résultat de l’algorithme est la sortie (oh le beau gâteau!!)
2
2.1
Bases du language de programmation pascal
Objets de bases
Un programme Turbo Pascal décrit un enchainement d’instruction portant sur des objets.
Ces objets sont des données constantes ou des variables :
① CONSTANTE = une donnée constante est une donnée dont la valeur est fixée par le programmeur et qui
reste inchangée au cours de l’exécution du programme.
Un exemple important est la constante ”chaı̂ne de caractères” (ou string) : ’bonjour’ ou ’rerevgeetr’ . . . Pour
définir une chaı̂ne de caractères, il suffit de mettre une suite de caractères à l’intérieur de ’ ’.
② VARIABLE = une donnée variable est une donnée dont la valeur est initialisée par le programmeur ; cette
valeur peut être modifiée au cours de l’exécution du programme.
Exemple : Dans la première algorithme de calcul de (1, 7)64 , les objets sont : 1, 7 (constante), 64 (constante)
ainsi que ”le résultat intermédiaire” (variable).
Tous ces objets vont avoir des noms définis par le programmeur : ces noms s’appellent des identificateurs.
 Ces identificateurs ne peuvent pas être des mots réservés c.a.d. des mots dont la signification est prédéfinie
par le logiciel, tels que ’REAL’ ; ’BEGIN etc . . . .
De plus il ne peut y avoir ni espace ni lettres accentuées dans un identificateur, et le premier caractère ne doit pas
être un chiffre.
2.2
Structure d’un programme en language Turbo Pascal
Structure d’un programme Turbo Pascal.
• L’en-tête du programme :
•
•
•
•
PROGRAM nom du progamme ;
Les déclarations (variables, constantes, types des variables, procedures, fonctions..)
begin
le programme
end.
2.3
Types des variables
Les variables correspondent à divers type, correspondant à la nature des valeurs qui peuvent leur être affectées.
En effet, déclarer un type pour une variable permet de réserver une case mémoire adaptée aux valeurs que va
prendre cette variable tout au long de l’éxecution de programme.
Les principaux types d’objet sont :
⋆ type entier : integer =⇒ Ils doivent être compris entre -32768 et +32767.
⋆ type réel : real
⇐⇒ Ils doivent être compris entre 2, 910−39 et 1, 71038 avec 11 décimales
⋆ type booléen : boolean =⇒ Il définit deux valeurs logiques : TRUE (vrai) ou FALSE (faux).
Par exemple, si x est connu la variable (x > 0) est de type booléen.
⋆ type charactère ; char =⇒ Ces variables contiennent un caractère.
⋆ type chaı̂ne de charactère ; string =⇒ Ces variables contiennent une chaı̂ne de caractères.
=⇒ Il faut alors préciser le type des éléments du tableau qu’il doit prendre en
⋆ type tableau : array
compte. On verra ce type plus en détail dans une prochaine partie.
☞ Nous allons voir par la suite qu’il est possible de définir des types de variables à l’aide de l’instruction TYPE.
2.4
Déclaration des types(variables)/valeurs(constantes) des objets
Il faut déclarer le type des variables ainsi que les valeurs des constantes dans la première partie du programme.
❶ Les valeurs des différentes constantes sont déclarées à l’aide de l’instruction CONST de la manière suivante :
Exemple 1 : CONST tauxtva = 17;
Exemple 2 : CONST message = ’Salut ca va?’;
❷ Les types des variables sont déclarées à l’aide de l’instruction VAR de la manière suivante :
Exemple 1 : VAR variable1, variable2, ..., variableN : REAL;
Exemple 2 : VAR i,k,n : INTEGER ;
☛ Lors de la phase de déclaration, regrouper les variables ayant même type.
2.5
Variables
En informatique, une variable est une ”case” mémoire, réservée pour stocker la future valer de cette variable
(valeur pouvant être modifiée au cours de l’exécution du programme). Pour être utilisée une variable doit être :
• déclarée : une variable doit avoir un nom (identificateur) ainsi qu’un type (entier, réel, etc. . . ) qui va
définir la taille de la case mémoire à réserver.
VAR x,a,b :
REAL;
• initialisée : on doit donner une valeur initiale à la variable. Deux moyens sont possibles :
a) par affectation directe : on attribue une valeur à la variable x préalablement déclarée par l’instruction
x :
= 1
b) affectation intéractive par écriture/lecture :
i/ on demande à l’utilisateur du programme de rentrer à l’écran les valeurs initiales pour une ou
plusieurs variables
writeln (’écrire les valeurs de a et b’);
ii/ la ou les valeurs écrites par l’utilisateur sont affectées aux variables en questions.
readln (a,b);
Remarque : Supposons avoir déjà initialisé la variable a. Si l’on a veut affecté à la variable b, la même valeur
qu’à a il est possible d’utiliser l’instruction
b : = a ;
à condition que ces deux variables soient déclarées de même type!!!
 ATTENTION : Ne pas confondre l’instruction d’affectation directe ”:=” avec le ”=” réservé aux données
constantes et au symbole de comparaison!!!
2.6
Opérateurs élémentaires
Ces opérations dépendent du type des objets (variables ou constantes). Attention, les opérations doivent être
effectuées entre objets de même type.
❶ Opérations arithmétiques
opérateurs
entrées
sortie
+ ; - ; * ; /
réel ou entier réel ou entier
div ; mod
entier
entier
quotient ou reste de la division euclidienne
exp ; ln ; sqrt
réel
réel
sqrt est la racine carrée
sqr
réel/entier
réel/entier
carré
trunc
réel
entier
partie entière
abs
réel/entier
réel/entier
valeur absolue
❷ Opérateurs relationnels
= ; <> pour traduire 6= ; < ; < ; <= pour 6 et >= pour >.
❸ Opérateurs logiques
Ils sont au nombre de quatre : not ; or ; and ; xor (OU exclusif).
Ces opérateurs servent généralement à définir des variables booléennes c’est à dire des propositions mathématiques
prennant les valeurs V RAIE ou F AU SSE selon si celles-ci sont vérifiées ou pas.
On verra que ces variables de type booléen et donc les opérateurs ci-dessous, sont souvent utilisé dans les instructions conditionnelles selon les modèles :
if variable booléenne then instructions 1 else instructions 2
while variable booléenne do instructions
repeat instructions until variable booléenne
Exemples :
if
while
2.7
x>2
then
(x<-1)
and
a:=-3
(x>1)
do
Les variables de type tableau
Les tableaux peuvent être à une ou plusieurs dimensions. Ils se prêtent principalement :
i) à la représentations de n-uplets ou de matrices.
ii) au stockage des données (on verra qu’il est possible de générer des expériences aléatoires et d’en stocker
les différents résultats).
2.7.1
Déclarer une variabe de type ”tableau”
VAR M : ARRAY[ taille ]
OF
type des nombres du tableau
Exemples :
1) tableau à une entrée (un vecteur)
VAR M : ARRAY[1..4]
OF
REAL
Cette ligne, déclare la variable M comme un élément de R4 .
2) tableau à double entrées (une matrice)
VAR M : ARRAY[1..4,1..3]
OF
REAL
Cette ligne, déclare la variable M comme un élément de M4,3 (R) (4 lignes et 3 colonnes).
2.7.2
Accéder aux éléments du tableau
Chacune des cases du tableau ainsi déclaré est un variable du type ”type des nombres du tableau” et identifiée
par :
M[i] (le ’[i]’ représente le numéro de la case dans le tableau à une entrée)
M[i,j] ( le couple ’[i,j]’ représente le numéro de la ligne et de la colonne de l’emplacement de la variable)
 ATTENTION : Au départ, le tableau est vide !! Il faut penser à l’initialiser toutes les cases du tableau avant
de l’utiliser!!
2.7.3
Créer un type ”tableaux”
Pour pouvoir appliquer des fonctions ou des procédures (voir plus loin) à un tableau, il faut donc déclarer le type
de ce tableau en amont. De même, par commodité, si l’on souhaite travailler avec plusieurs matrice de M3 (R) il
est préférable de créer un type ”matrice de taille 3×3”...
☛ La déclaration d’un nouveau type se fait juste avant la déclaration des variables!!
TYPE
matrice = ARRAY[1..3,1..3]
OF
REAL ;
Ainsi dans la suite du programme, il est possible de déclarer (par exemple) 4 variables A, B, C et D en tant que
matrice de taille 3 × 3 par :
VAR A, B, C, D : matrice ;
2.7.4
Opérations sur les tableaux
La seule opération globale que Turbo-Pascal sait réaliser sur les tableaux est l’affectation en bloc des valeurs d’un
tableau dans un tableau identique (même dimensions et même type de contenu)
Ainsi si R et A sont des tableaux identiques alors
R:= A
remplace le contenu du tableau R par celui du tableau A.
2.7.5
Initialiser un tableau
Plusieurs possibilités pour initialiser efficacement le contenu d’un tableau :
i) utiliser une boucle itérative FOR pour initaliser tout les éléments du tableau à 0.
VAR
k :
VAR
M : ARRAY[1..12]
FOR k:=1
INTEGER ;
TO
12
OF
REAL ;
DO M[k]:=0 ;
ii) utiliser une boucle FOR pour initaliser les éléments du tableau à des valeurs entrées par l’utilisateur.
Exemple 1 : initialiser un tableau à une entrée par saisie de l’utilisateur.
VAR
k :
VAR
M : ARRAY[1..12]
FOR k:=1
INTEGER ;
TO
12
OF
REAL ;
DO
BEGIN
WRITELN (’Entrer la valeur de la case’,k) ;
READLN (M[k]) ;
END ;
Exemple 2 : initialiser un tableau double entrées par saisie de l’utilisateur.
VAR
i, j :
VAR
M : ARRAY[1..4,1..5]
FOR i:=1
FOR
TO
j:=1
INTEGER ;
4
TO
OF
REAL ;
DO
5
DO
BEGIN
WRITELN (’Entrer la valeur de la ligne’,i,’colonne’,j) ;
READLN (M[i,j]) ;
END ;
3
Instructions conditionnelles
Une instruction conditionnelle est une instruction dont l’action dépend de la valeur d’une proposition :
• si la condition est vraie alors on effectue une instruction 1
• sinon on effectue une instruction 2.
instruction A
IF condition THEN
BEGIN
instructions 1 ;
END
ELSE
BEGIN
instructions 2 ;
END ;
instruction C
Définition - Instructions simples/composées
Une instruction est dite simple si elle se réduit à une seule commande : writeln(’bonjour’) ou s:= 0.
Sinon l’instruction est dite composée.
Une instruction composée est donc une suite d’instructions terminées par un ”; ” : l’ensemble de ces instructions
doit alors commencer par un BEGIN et finir par un END ; . Pour des raisons de lisibilité, on utilise très souvent une
présentation décalée :
BEGIN
instruction 1 ;
instruction 2 ;
instruction 3
END ;
où instruction1, instruction2, et instruction3 peuvent être des instructions simples ou composées.
Le point virgule ”; ” est en fait un séparateur d’instructions : c’est pourquoi il n’est pas nécessaire d’en insérer un
à la fin de l’ instruction3.
Remarques :
① Si les instructions 1 ou 2 sont simples le BEGIN ...END n’est pas utile!!
② Le ELSE est facultatif, mais ne doit pas être précédé immédiatement d’un ”;”.
4
Boucles itératives
4.1
Boucle FOR
L’idée de la boucle FOR : on répète une suite d’instructions un certain nombre de fois. L’utilisation d’une telle
boucle nécéssite la déclaration du variable (indice de décompte).
La syntaxe est la suivante :
VAR
i :
INTEGER ;
...
instruction A
FOR
i:= n1
TO
n2
DO
BEGIN
instructions B ;
END ;
instruction C
 ATTENTION : Le groupe d’instructions B est effectué une première fois avec i = n1 , la deuxième fois avec
i = n1 + 1,. . . , la dernière fois avec i = n2 .
4.2
4.2.1
Boucles conditionnelles
Boucles WHILE
L’idée de la boucle WHILE : on répète une suite d’instructions tant qu’une certaine condition reste vraie.
La syntaxe est la suivante :
instruction A
WHILE condition DO
BEGIN
instruction B ;
END ;
instruction C
 ATTENTION : Ce type de boucle peut ne jamais s’achever si la condition reste toujours vraie. Assurez vous
bien que celle-ci devient donc fausse au bout d’un certain temps!!!
4.2.2
Boucles REPEAT
L’idée de la boucle REPEAT : on répète une suite d’instructions jusqu’à ce qu’une certaine condition soit vraie.
La syntaxe est la suivante :
instruction A
REPEAT
instruction B ;
UNTIL condition;
instruction C
 ATTENTION : Le REPEAT ...UNTIL permet de délimiter l’instruction B! Nul besoin donc de BEGIN ...END!
Attention également de bien vous assurer que la condition devient vraie au bout d’un certain temps : sinon
le programme ne s’arrete jamais.
5
Fonctions et procédures
La notion de sous-programme représente toute la puissance du langage Turbo Pascal. En fait c’est la possibilité de
structurer encore davantage le programme en créant de nouveaux ordres utilisables dans le corps du programme
mais non définis dans celui-ci. Celà permet d’avoir un programme beaucoup plus lisible puisque l’on décompose
ainsi le programme en actions simples ou blocs d’instructions.
5.1
Fonctions
Définition - Fonction sous TPascal
Une fonction est un sous-programme qui fournit un résultat à partir des données qu’on lui apporte : la notion de
fonction en Turbo-Pascal est assez proche de la notion de fonction en mathématiques.
Une fonction se déclare comme suit :
FUNCTION Nom de la fonction ( Nom du paramètre : Type du paramètre ) : Type de sortie
VAR déclaration des éventuelles variables ou constantes (utile à la fonction)
BEGIN
Corps de la fonction (listes des instructions séparées par des ”; ”)
Nom de la fonction := Valeur de sortie ;
END ;
Remarques :
① Une fonction ne peut avoir en sortie qu’un réel ou un entier!!
② Il peut y avoir plusieurs paramètre d’entrées dans une fonction.
Ils seront alors séparés par un ”; ” dans la déclaration mais lors de l’appel de la fonction dans le corps du programme, ils seront séparés par une ”, ” .
√
Exemple 1 : Fonction donnant l’image d’un nombre
√ par la fonction mathématiques x → 3 x + 2
Après voir définit la fonction, l’utiliser afin de calculer 3 3 + 2.
PROGRAM
Exemple1 ;
FUNCTION
f
(x :
REAL )
: REAL
BEGIN
f
:=
3*sqrt(x)+2
END ;
BEGIN
WRITE(f(3))
END .
Exemple 2 : Fonction associant à un entier positif n sa factorielle n!.
PROGRAM
Exemple2 ;
FUNCTION
factorielle
VAR i ,
F
:
(N :
INTEGER )
: INTEGER ;
INTEGER ;
BEGIN
F:=1 ;
FOR i:=1 TO
N DO
F:=F*i ;
factorielle:=F ;
END .
Compléter le programme ci-dessus de l’exemple 2 afin d’utiliser la fonction factorielle dans le calcul de du coefficient
binomial (nk ). On demandera à l’utilisateur d’entrer les valeurs de n et k.
5.2
Procédures
Définition - Procédures sous TPascal
CONTRAIREMENT aux fonctions, la procédure ne fournit pas un résultat mais crée une action ou une suite
d’actions (instructions) : on utilisera les procédures principalement lorsqu’on manipulera des tableaux (matrices ou autres). En effet, une fonction ne permet pas de modifier un tableau puisque en sortie elle renvoie un réel.
La syntaxe d’une procédure est double :
SYNTAXE 1
PROCEDURE Nom de la fonction ( Nom du paramètre : Type du paramètre ) ;
VAR déclaration des éventuelles variables ou constantes (via CONST)
BEGIN
Corps de la fonction (listes des instructions séparées par des ”; ”)
END ;
SYNTAXE 2
PROCEDURE Nom de la fonction ( VAR Nom du paramètre : Type du paramètre ) ;
VAR déclaration des éventuelles variables ou constantes (via CONST)
BEGIN
Corps de la fonction (listes des instructions séparées par des ”; ”)
END ;
Essayons de comprendre la différence entre ces deux syntaxes sur l’exemple suivant.
Exemple
PROGRAM
VAR
PROGRAM
proc ;
VAR
A : REAL ;
PROCEDURE
P
(x :
REAL ) ;
proc ;
A : REAL ;
PROCEDURE
P1
(VAR x :
BEGIN
BEGIN
write(x) ;
write(x) ;
x:=x+1
x:=x+1
writeln(x) ;
writeln(x) ;
END ;
END ;
BEGIN
BEGIN
A;=5 ;
A;=5 ;
P(A) ;
P1(A) ;
write(A) ;
write(A) ;
END .
L’affichage de la syntaxe 1 est : 56
5
END .
L’affichage de la syntaxe 2 est : 56
6
REAL ) ;