ANNEXE EX P
EXEMPLES DE PROGRAMMES PASCAL
Cette annexe contient plusieurs exemples de programmes écrits en
Pascal et fonctionnant sur Macintosh. Ces programmes sont conçus
de telle manière que :
- chacun illustre spécialement l'utilisation d'un (ou de plusieurs) point du langage Pascal
- leur style soit un très bon exemple de ce qu'il faut faire pour obtenir des programmes clairs et lisibles.
Dans chaque exemple une note mentionne les notions de Pascal nécessaires pour comprendre le programme. Ces notes désignent les paragraphes ou chapitres du cours "Introduction à l'informatique" utilisés; elles se présentent sous la forme du commentaire
(* Pascal utilisé : jusqu'à la fin du .....
*)
Sommaire | |
| Exemple 1 | Créer un générateur de nombre aléatoires. Ce générateur nous affichera un nombre compris entre 0 et 1. |
| Exemple 2 | Créer une table de Pythagore, c'est-à-dire une table ou l'intersection entre ligne et colonne représente la multiplication des deux. |
| Exemple 3 | Programme calculant le plus grand commun diviseur de 2 nombres entiers. |
| Exemple 4 | Donner soit le code ASCII d'un caractère, soit le caractère à partir de son code ASCII. |
| Exemple 5 | Construire une fonction arcsinus donnant l'angle en radians à partir de son sinus. |
| Exemple 6 | Programme permettant de résoudre une équation du 2ème degré ( solutions réelles ou complexes ). |
| Exemple 7 | Programme permettant de calculer la puissance entière, positive ou négative d'un nombre réel. |
[ Retour à
la table des matières ]
(************************************************************************) (* *) (* Nom du fichier : GEN_ALEA.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 21.5.1987 *) (* *) (* But : Créer un générateur de nombre aléatoires. *) (* Ce générateur nous affichera un nombre *) (* compris entre 0 et 1. *) (* *) (* *) (* Date de modification : 24.7.1987 PBT *) (* Raison de la modif. : soigner le style *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program gen_alea ( input,output ); (* Programme pouvant être aisément transformé en une fonction. *) (* Pascal utilisé : jusqu'à la fin du paragraphe 4.1 *)
const pi = 3.14159; (* valeur de pi ( 6 chiffres significatifs) *)
max = 10; (* quantité de nombres aléatoires affichés *)
var aleatoir : real; (*nombre aléatoire (résultat) *)
tempo : real; (* variable de travail temporaire *)
compteur : integer; (* variable de boucle *)
begin (* gen_alea *)
showtext;
(* présentation du programme et lecture des données *)
writeln ('Bonjour. Je calcule', max : 4,' nombres aléatoires');
write ('Entrez un nombre entre 0 et 10 : ' : 40 );
readln (aleatoire); (* valeur à partir de laquelle sera calculé le *)
writeln; (* premier nombre aléatoire *)
for compteur := 1 to max do (* on affiche max nombres *)
begin
tempo := aleatoire + pi (* début du calcul d'un nombre aléatoire *)
tempo := exp ( 5.0 * ln ( tempo ) );
aleatoire := tempo - trunc ( tempo );
writeln (aleatoir : 40 : 4 );
writeln;
end;
end.
EXEMPLE 2
(************************************************************************) (* *) (* Nom du fichier : TABLE_PYTHA.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 21.5.1987 *) (* *) (* But : Créer une table de Pythagore, c'est-à-dire *) (* une table ou l'intersection entre ligne et *) (* colonne représente la multiplication des *) (* deux *) (* *) (* Date de modification : 24.7.1987 PBT *) (* Raison de la modif. : soigner le style *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program table_pytha ( input, output ); (* Pascal utilisé : jusqu'à la fin du paragraphe 4.1 *)
var nombre_ligne_col : integer; (* nombre de lignes ( ou de colonnes ) que *)
(* contiendra la table *)
i, j : integer; (* variables de boucle *)
begin (* table_pytha *)
showtext;
(* présentation du programme et lecture des données *)
writeln ('Bonjour. Je calcule une table de Pythagore. Cette table est carrée.');
write ('Quel nombre de lignes ( donc de colonnes ) désirez-vous ? : ');
readln ( nombre_ligne_col );
writeln;
writeln ('Table de Pythagore' : 50 ); (* titre de la table produite comme résultat *)
writeln ('------------------' : 50 );
writeln;
for i := 1 to nombre_ligne_col do (* boucle traitant les lignes *)
begin
for j:= 1 to nombre_ligne_col do (* boucle traitant les colonnes *)
write ( i * j : 6 ); (* calcul d'un élément de la table *)
writeln; (* écriture d'une ligne de la table *)
writeln; (* on laisse une ligne vide entre chaque ligne *)
end;
end
(************************************************************************) (* *) (* Nom du fichier : PGCD.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 2.6.1987 *) (* *) (* But : Programme calculant le plus grand commun *) (* diviseur de 2 nombres entiers *) (* *) (* *) (* *) (* Date de modification : 24.7.1987 PBT *) (* Raison de la modif. : soigner le style *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program pgcd ( input, output ); (* Pascal utilisé : jusqu'à la fin du paragraphe 4.4 *)
var nombre_1 : integer; (* variable qui va contenir le premier nombre *)
nombre_2 : integer; (* varibale qui va contenir le deuxième nombre *)
begin (* pgcd *)
showtext;
writeln; (* présentation du programme *)
writeln ('Programme calculant le PGCD de deux nombres entiers' : 65 );
writeln;
writeln; (* lecture des données *)
write ('Valeur du premier nombre : ' : 40 );
readln ( nombre_1 );
writeln;
write ('Valeur du deuxième nombre : ' : 40 );
readln ( nombre_2 );
writeln;
(* calcul du PGCD *)
while nombre_1 <> nombre_2 do (* PGCD trouvé lorsqu'ils sont égaux *)
if nombre_1 > nombre_2 then (* soustraire le plus petit du plus grand *)
nombre_1 := nombre_1 - nombre_2
else nombre_2 := nombre2_ - nombre_1;
writeln;
writeln ('Le PGCD des deux nombres est : ' : 60, nombre_1 : 5 );
end.
(************************************************************************) (* *) (* Nom du fichier : CONVERSIONS.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 20.5.1987 *) (* *) (* But : Donner soit le code ASCII d'un caractère, *) (* soit le caractère à partir de son code *) (* ASCII *) (* *) (* *) (* Date de modification : 24.7.1987 PBT *) (* Raison de la modif. : soigner le style *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program conversions ( input, output ); (* Pascal utilisé : jusqu'à la fin du chapitre 4 *)
const plus_grand_code = 127; (* valeur limite du code ASCII standard *)
premier_car_imp = ''; (* l'espace est le premier caractère imprimable *)
dernier_car_imp = '~'; (* le tilde est le dernier caractère imprimable *)
en_ascii = 1; (* converstion en ASCII *)
en_caractere = 2; (* converstion en caractère *)
var caractere : char; (* caractère lu *)
nombre : integer; (* nombre lu *)
choix : integer; (* choix du type de conversion *)
fin : boolean; (* pour l'arrêt du programme *)
begin (* conversions *)
showtext;
writeln; (* présentation du programme *)
writeln,
writeln ('Ce programme donne le code ASCII d'' un caractere, ou le caractere');
writeln ('a partir d''un code ASCII.');
writeln;
fin := false;
while not fin do (* tant que l'utilisateur veut continuer *)
begin
writeln;
writeln;
(* on répète jusqu'au bon choix de l'utilisateur *)
choix := 0;
while ( choix <> en_ascii ) and ( choix <> en_caractere ) do
begin
write ('Conversion en ASCII < 1 >, conversion en caractere < 2 > : ' : 65 );
readln ( choix );
end;
if choix = en_ascii then
begin (* conversion d'un caractère en code ASCII *)
write ('Introduisez un caractere : ' : 65 );
read ( caractere );
writeln;
writeln ('Le code ASCII de ', caractere, 'est : ', ord ( caractere ) : 4 );
end
else (* conversion d'un code ASCII en caractere *)
begin
write ('Introduisez un code ASCII : ' : 65 );
readln ( nombre );
writeln;
(* le nombre peut-il être converti ? *)
if ( nombre >= 0 ) and ( nombre <= plus_grand_code ) then
(* le nombre peut-il être affiché ? *)
if ( nombre >= ord ( premier_car_imp ) ) and
( nombre <= ord ( dernier_car_imp ) ) then
begin
write ('Le caractere ayant pour code ASCII', nombre : 4 );
writeln ('est :', chr ( nombre ) );
end
else begin
write ('Le caractere correspondant est un caractere de controle');
writeln ('non imprimable');
end
else
writeln ('Nombre négatif ou trop grand pour être converti !!!!!!!');
end;
writeln; (* l'utilisateur veut-il continuer ou terminer ? *)
write ('Voulez-vous continuer ( oui = O, non = N ) ? : ' : 65 );
read ( caractere );
fin := ( caractere = 'n' ) or ( caractere = 'N' ); (* condition de fin de programme *)
end;
end.
EXEMPLE 5
(************************************************************************) (* *) (* Nom du fichier : ARCSIN.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 11.6.1987 *) (* *) (* But : Construire une fonction acrsinus donnant *) (* l'angle en radians à partir de son sinus *) (* *) (* *) (* *) (* Date de modification : 24.7.1987 PBT *) (* Raison de la modif. : soigner le style *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program arcsin ( input, output ); (* ce programme contient et utilise une fonction : la fonction arcsinus *) (* Pascal utilisé : jusqu'à la fin du chapitre 5 *)
const pi = 3.14159;
var nombre : real; (* nombre dont on veut calculer l'arcsinus *)
function arcsinus ( sinus : real ) : real;
(* cette fonction nous donne les angles en radians *)
(* Paramètre : sinus valeur d'un sinus à partir de laquelle on cherche l'angle *)
const zero = 0.0 (* trois sinus particuliers *)
moins_un = -1.0;
plus_un = 1.0;
begin (* arcsinus *)
(* il existe 3 cas particuliers et un cas général *)
if sinus = zero then (* 1er cas particulier *)
arcsinus := 0.0
else if sinus = plus_un then (* 2e cas particulier *)
arcsinus := pi / 2.0
else if sinus = moins_un then (* 3e cas particulier *)
arcsinus := - pi / 2.0
else (* cas général *)
arcsinus := arctan ( sinus / sqrt ( 1.0 - sqr ( sinus ) ) );
end; (* arcsinus *)
begin (* arcsin *)
showtext;
(* présentation du programme *)
writeln;
writeln;
writeln ('Programme permettant de donner un angle en radians a partir de son sinus');
writeln;
writeln;
(* lecture des données *)
write ('Donner la valeur de votre sinus ( entre -1.0 et 1.0 ) : ' : 40 );
readln ( nombre );
writeln;
nombre := arcinus ( nombre ); (* calcul de l'angle à l'aide de la *)
(* fonction arcsinus *)
(* écriture des résulats *)
writeln;
writeln ('L''arcsinus de votre sinus est : ' : 40, nombre : 9 : 5 );
end.
EXEMPLE 6
(************************************************************************) (* *) (* Nom du fichier : RES_EQUATION_2.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 30.5.1987 *) (* *) (* But : Programme permettant de résoudre une équa- *) (* tion du 2ème degré ( solutions réelles et *) (* complexes *) (* *) (* *) (* Date de modification : 25.7.1987 PBT *) (* Raison de la modif. : soigner le style, correction d'erreurs *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program res_equation ( input, output ); (* Pascal utilisé : jusqu'à la fin du paragraphe 7.2 *) (* Nous avons ici 5 cas différents qui peuvent se présenter : l'équation du 2ème degré *) (* peut être soit dégénérée, de degré 1, avoir des solutions réelles ou complexes. *) (* distinctes ou complexes *)
const nb_positions = 15; (* colonnes utilisées pour écrire les solutions *)
type t_cas_possible = ( degeneree, degre_1, relle, double, complexe );
var cas : t_cas_possible; (* 5 cas possibles *)
discriminant : real; (* b2 - 4ac *)
coef_degre_2 : real; (* coefficient du terme du 2e degré *)
coef_degre_1 : real; (* coefficient du terme de degré 1 *)
coef_degre_0 : real; (* coefficient du terme de degré 0 *)
x1, x2 : real; (* 2 solutions *)
reel, imaginaire : real; (* en cas de solutions complexes *)
begin (* res_equation *)
showtext;
writeln; (* présentation du programme *)
writeln ('Programme de resolution d'equation du 2e degre');
writeln; (* lecture des coefficients *)
write ('Coefficient du terme de degre 2 : ' : 50 );
readln ( coef_degre_2 );
write ('Coefficient du terme de degre 1 : ' : 50 );
readln ( coef_degre_1 );
write ('Coefficient du terme de degre 0 : ' : 50 );
readln ( coef_degre_0 );
(* détermination des différents cas possible *)
if coef_degre_2 = 0 then (* degré 1 ou dégénérée *)
if coef_degre_1 = 0 then cas := degeneree
else cas := degre_1
else (* degré 2 *)
(* calcul du discriminant *)
discrimant := sqr ( coef_degre_1 ) - 4.0 * coef_degre_2 * coef_degre_0;
if discriminant = 0 then cas := double (* racines réelles confondues *)
else if discriminant > 0 then cas := relle (* racines réelles distinctes *)
else cas := complexe; (* racines complexes *)
(* calcul des racines dans chacun des cas *)
case cas of
degenere: (* cas dégénéré *)
if coef_degre_0 <> 0 then writeln ('IMPOSSIBLE' : 35 )
else writeln ('INDETERMINE' : 35 );
degre_1 : begin (* cas degré 1 *)
write ('solution : X = ');
writeln ( - coef_degre_0 / coef_degre_1 : nb_positions : 5 );
end;
double : begin (* cas racines confondues *)
write ('solution double : X1 = X2 = ' : 35 );
writeln ( - coef_degre_1 / ( coef_degre_2 * 2.0 ) : nb_positions : 5 );
end;
reelle : begin (* cas racines distinctes *)
X1 := ( - coef_degre_1 + sqrt ( discriminant ) / ( coef_degre_2 * 2.0 );
X2 := ( - coef_degre_1 - sqrt ( discriminant ) / ( coef_degre_2 * 2.0 );
writeln ('solutions : X1 = ' : 35, X1 : nb_positions : 5 );
writeln ('X2 = ' : 35, X2 : nb_positions : 5 );
end;
complexe : begin (* cas racines complexes *)
reel := - coef_degre_1 / ( coef_degre_2 * 2.0 );
imaginaire := sqrt ( - discriminant ) / ( coef_degre_2 * 2.0 );
write ('solutions : X1 = ' : 35, reel : nb_positions : 5 );
writeln (' + i', imaginaire : nb_positions : 5 );
write ('X2 = ' : 35, reel : nb_positions : 5 );
writeln (' -i', imaginaire : nb_positions : 5 );
end;
end; (* case *)
end.
EXEMPLE 7
(************************************************************************) (* *) (* Nom du fichier : PUISSANCE_REC.PAS *) (* Auteur(s) : J. Skrivervik EI-6 *) (* Date : le 4.6.1987 *) (* *) (* But : Programme permettant de calculer la puis- *) (* sance entière, positive ou négative d'un *) (* nombre réel. *) (* *) (* *) (* Date de modification : 25.7.1987 PBT *) (* Raison de la modif. : soigner le style *) (* Module(s) appelé(s) : *) (* Matériel particulier : *) (* Modalités d'exécution : *) (* *) (************************************************************************) program puissance_recursive ( input, output ); (* Pascal utilisé : jusqu'à la fin du chapitre 11 *)
var nombre : real; (* nombre qui va être élevé à la puissance exposant *)
exposant : integer (* la puissance considérée *)
function puissance ( nombre : real; exposant : integer ) : real;
(* fonction permettant de calculer une puissance de manière récursive *)
(* Paramètres : nombre nombre ( <> 0 ) qui va être élevé à une certaine puissance *)
exposant puissance considérée *)
begin (* puissance *)
if exposant = 0 then (* condition d'arrêt de l'appel récursif *)
puissance := 1.0
else if exposant > 0 then (* exposants positifs *)
puissance := puissance ( nombre, exposant - 1 ) * nombre
else (* exposants négatifs *)
puissance := puissance ( nombre, exposant + 1 ) / nombre;
end; (* puissance *)
begin (* puissance_recursive *)
showtext;
writeln; (* présentation du programme *)
writeln;
writeln ('Programme permettant d'elever un nombre a une puissance positive ou negative' : 65 );
writeln;
writeln; (* lecture des données *)
write ('Nombre a elever a une certaine puissance : ' : 45 );
readln ( nombre );
writeln;
if nombre <> 0.0 then (* on demande la puissance seulement s'il faut calculer! *)
begin
write ('Puissance considérée : ' : 45 );
readln ( exposant );
writeln;
writeln;
(* fin du dialogue avec l'utilisateur. Ecriture des résultats *)
write ('SOLUTION : ' : 45, puissance ( nombre, exposant ) : 15 : 5 );
end
else writeln ('Aucun interet d'elever 0 a une certaine puissance!');
end.