Embed Size (px)
Citation preview
Langages de programmation Un ordinateur est une machine bête, ne sachant qu'obéir, et à très peu de choses :
Addition, soustraction, multiplication en binaire, uniquement sur des entiers;
Sortir un résultat ou lire une valeur binaire (dans une mémoire par exemple);
Comparer des nombres.
Sa puissance vient du fait qu'il peut être programmé, c'est à dire que l'on peut lui donner, à l'avance, la séquence (la suite ordonnée) des ordres à effectuer l'un après l'autre. Le grand avantage de l'ordinateur est sa rapidité. Par contre, c'est le programmeur qui doit tout faire. L'ordinateur ne comprenant que des ordres codés en binaire (le langage machine), des langages dits "évolués" ont été mis au point pour faciliter la programmation. Le Pascal, créé par Wirth au début des années 70, possède des instructions assez claires (si vous comprenez l'anglais) et favorise une approche méthodique et disciplinée (on dit "structurée"). Le Pascal est un langage compilé, c'est-à-dire qu'il faut :
Entrer un texte dans l'ordinateur (à l'aide d'un programme appelé éditeur);
Le traduire en langage machine (c'est-à-dire en codes binaires compréhensibles par l'ordinateur) : c'est la
compilation et éventuellement l'édition de liens(Link);
L'exécuter.
Contrairement à une application smartphone, l'exécution sera beaucoup plus rapide puisqu'il n'y a plus de traduction à effectuer.
Un premier petit programme Un programme Pascal est composé d'une entête, des déclarations et des instructions (délimitées par BEGIN et END.). PROGRAM cercle(input,output); (* entête *) VAR perimetre, diametre : REAL; (* déclarations *)
BEGIN
readln(diametre); (* instruction *)
perimetre := 3.141592* diametre; (* instruction *)
writeln(diametre,perimetre) (* instruction *)
END.
L'entête est composée du mot PROGRAM, suivi du nom du programme (cercle), et d'indications sur les Entrées/ Sorties (ici le clavier et l'écran). La partie déclarative de notre programme est limitée à la déclaration de deux variables (mot-clef VAR). Une variable est une "case" mémoire de l'ordinateur, à laquelle on donne ici un nom. Chaque case peut contenir une valeur. On a précisé ici que nos deux variables perimetre et diametre contiendraient des réels. Les types simples de variable connus en Pascal sont : • REAL : nombre à virgule; • INTEGER : entier naturel compris entre -32768et +32767; • CHAR : contient un et un seul caractère; • BOOLEAN : booléen, c'est-à-dire qui peut valoir soit TRUE(vrai) soit FALSE(faux). Remarque : La virgule décimale est toujours représentée par un point en informatique.
Algorithmique au collège - Séance 1 -
Un identificateur (tout nom que vous choisissez : variable, programme...) peut être formé de lettres (A à Z), de chiffres et (pas sur toutes les versions de Pascal) du signe _ (souligné). Remarque 1 : Turbo Pascal accepte des noms de 127 caractères maximum). Le premier caractère doit être une lettre. Par exemple, valeur1 ou prem_valeur sont possibles mais pas 1ere_valeur. Remarque 2 : En Pascal, les minuscules sont traitées comme des majuscules (SURface et surFACE désignent la même case mémoire).On n'utilise les majuscules que pour faire ressortir les mots importants. Remarque 3 : Les accents et autres ç ne sont pas autorisés (var diamètre : real est interdit à cause de l'accent). Un blanc dans un identificateur est également interdit (utilisez _ pour séparer des mots dans un même identificateur). Toute variable utilisée dans un programme doit être déclarée.
Analyse du programme Les instructions de notre programme sont :
readln(diametre); Lecture sur le clavier : le programme s'arrête, attend que l'on donne une valeur à
l'aide du clavier, met cette valeur dans la case diametre et continue lorsque l'on appuie sur la touche
"ENTREE" ou "RETURN".
perimetre := 3.141592* diametre ; Calcul et affectation : on multiplie le contenu de la case
diametre par PI et on met le résultat dans la case perimetre. Le := symbolise une flèche à gauche. Ce
n'est PAS une égalité au sens mathématique, mais la copie d'une valeur dans une mémoire.
writeln(diametre,perimetre) ; Ecriture sur l'écran : on affiche sur l'écran le contenu des cases
diametre (que l'on connaissait puisque nous l'avions donné) et perimetre (qui nous intéresse un peu
plus). Ce programme affiche donc deux chiffres.
Il serait plus parlant d'afficher également des commentaires par l'instruction : writeln('Diamètre : ',diametre,', Périmètre : ',perimetre); Les textes doivent être entourés de cotes ('). Les majuscules/minuscules sont significatives. Pour afficher une apostrophe, utiliser deux cotes ('l''exemple'). Pour sauter une ligne, utiliser WRITELN seul. Les instructions doivent toujours être séparées par des " ;" (j'ai dit "séparées", pas "terminées"). Le fait de passer à la ligne n'est interprété par l'ordinateur que comme un blanc. On aurait donc pu écrire notre programme sur une seule ligne (peut-être un peu longue pour l'éditeur). Le programme doit toujours se terminer par un point.
Exercices Ecrire un programme qui demande le rayon d’un disque et qui en calcule l’aire
Pour rappel : 𝐴𝑑𝑖𝑠𝑞𝑢𝑒 = 𝜋 × 𝑟2
Remarque : Turbo Pascal ne reconnait pas « ² », il faut écrire une multiplication. Ecrire un programme qui demande la longueur et la largeur d’un rectangle qui en calcule l’aire et le périmètre.
Les types de variables standard simples et opérateurs associés En Pascal, toutes les variables déclarées doivent être typées. De plus, selon le type de variable, on ne pourra effectuer que certaines opérations spécifiques au type choisi.
Entiers Déclaration : VAR variable1, variable2, ..., variableN : INTEGER;
Opérations sur les entiers:
+ (addition)
- (soustraction)
* (multiplication)
DIV (division)
MOD (reste de la division)
Elles sont toutes à résultat entier et nécessitent deux arguments entiers.
Réels Déclaration : VAR variable1, variable2, ..., variableN : REAL;
Opérations sur les réels:
+ (addition)
- (soustraction)
* (multiplication)
/ (division)
Quand une opération comprend un argument réel et un entier, le résultat est réel. / donne toujours un résultat réel, même si les deux arguments sont entiers. * et / sont de priorité supérieure à + et -, mais entre * et / la priorité va de gauche à droite. En cas d'ambiguïté, utilisez des parenthèses (il n'y a aucun inconvénient à mettre plus de parenthèses que nécessaire). Exemples d'expressions numériques (soit A = 3, B = 4, C = 2) :
A + B / C = A + (B / C) = 5
(A + B) / C = 3.5
A / B * C = (A / B) * C (1.5) dans certains cas, A / (B * C) (0.375) dans d'autres
A / BC = valeur de A sur valeur de la variable de nom BC et non A sur B * C
B * A - 5 * C = (B * A) - (5 * C) = 2
Booléens Déclaration : VAR variable1, variable2, ..., variableN : BOOLEAN;
Ces variables peuvent prendre soit la valeur TRUE (vrai), soit la valeur FALSE (faux).
Algorithmique au collège - Séance 2 -
Opérations booléennes : AND
AND A
TRUE FALSE
B TRUE TRUE FALSE
FALSE FALSE FALSE
OR
OR A
TRUE FALSE
B TRUE TRUE TRUE
FALSE TRUE FALSE
NOT
NOT
A
TRUE FALSE
FALSE TRUE
XOR(ou exclusif)
XOR A
TRUE FALSE
B TRUE FALSE TRUE
FALSE TRUE FALSE
Ces opérations nécessitent des arguments booléens. Opérations à valeur booléenne:
> (supérieur)
< (inférieur)
>= (supérieur ou égal)
<= (inférieur ou égal)
= (égal)
<> (différent)
Ces opérations comparent tous éléments de type simple (les 2 arguments doivent être de même type, sauf entiers et réels qui peuvent être comparés entre eux), et renvoient un booléen. Exemple : (3>5) est égal à FALSE car 3 n’est pas supérieur à 5 (3>5) OR (6<10) est égal à TRUE car : (3>5) est FALSE, (6<10) est TRUE et FALSE OR TRUE est égal à TRUE.
Caractères Déclaration : VAR variable1, variable2, ..., variableN : CHAR;
Ces variables contiennent un caractère. Ceux-ci sont classés suivant un ordre précis (le code ASCII), qui suit l'ordre suivant :
Les chiffres '0' à '9' par ordre croissant;
Les majuscules 'A' à 'Z' par ordre alphabétique;
Les minuscules 'a' à 'z'.
Exercice Ecrire un programme qui demande deux nombres entiers a et b et qui calcule le quotient et le reste de la division euclidienne de a par b. Exemple de résultat
On peut utiliser des fonctions (qui peuvent soit être connues par le compilateur, soit définies par vous-même). Une fonction est un "module" ou "routine" qui renvoie une valeur au programme. Par exemple, A :=sqrt(B * C) met dans A la racine carrée de B fois C. B * C est appelé argument de la fonction.
Une fonction renvoie un résultat.
Les fonctions standards Les principales fonctions standard connues par tous les compilateurs sont : • ABS : renvoie la valeur absolue • SQR : renvoie le carré • SQRT : racine carrée • EX : exponentielle • LN : log népérien • SIN : sinus • COS : cosinus • ARCTAN : arc tangente • SUCC : variable énumérée suivante • PRED : variable énumérée précédente • ROUND : arrondi à l'entier le plus proche • TRUNC : partie entière d’un nombre Comme toute variable, une fonction possède un type (entier, réel,...) défini, et ne peut donc être utilisée que comme une variable de ce type. De plus, l’argument de la fonction est lui aussi typé : on ne peut pas demander le cosinus d’une variable de type CHAR.
Définir des fonctions « personnelles » Il est possible d’écrire et d’utiliser ses propres fonctions. L’entête est du type : FUNCTION Nom_fonction(liste_parametre) : type_de_la_fonction;
Chaque paramètre doit être typé mais on peut les regrouper par type. Voici un exemple : la fonction suivante va permettre de calculer le volume d’un pavé. FUNCTION volume(longueur,largeur,hauteur : REAL) : REAL;
BEGIN
volume := longueur*largeur*hauteur; END;
Analyse : FUNCTION volume(longueur,largeur,hauteur : REAL) : REAL;
La fonction volume a 3 paramètre longueur, largeur et hauteur qui sont des nombres à virgule et le résultat qu’elle renvoie est aussi un nombre à virgule. BEGIN ...
END;
Marque le début et la fin de la fonction.
Algorithmique au collège - Séance 3 -
volume := longueur*largeur*hauteur;
le résultat de la fonction volume est obtenu en faisant l’opération longueur × largeur × hauteur.
Utiliser une fonction « personnelle » On va maintenant écrire un programme utilisant notre fonction. PROGRAM Volume_du_pave;
VAR a,b,c,v : REAL;
FUNCTION volume(longueur,largeur,hauteur : REAL) : REAL;
BEGIN volume := longueur*largeur*hauteur;
END;
BEGIN
Writeln(‘Calcul du volume du pavé’);
Write(‘Entrez la longueur :’); Readln(a);
Write(‘Entrez la largeur :’);
Readln(b);
Write(‘Entrez la hauteur :’);
Readln(c);
v:= volume(a,b,c)
Write(‘Le volume de ce pave est ’,v); END.
Analyse du programme : VAR a,b,c,v : REAL;
Déclaration des variables : 3 variables pour la saisie des dimensions et une pour le calcule du volume. FUNCTION volume(longueur,largeur,hauteur : REAL) : REAL; BEGIN
volume := longueur*largeur*hauteur;
END;
Déclaration et définition de la fonction. Write(‘Entrez la longueur :’);
Readln(a); Write(‘Entrez la largeur :’);
Readln(b);
Write(‘Entrez la hauteur :’);
Readln(c);
Saisie des dimensions v:= volume(a,b,c)
Utilisation de la fonction pour calculer le volume Write(‘Le volume de ce pave est ’,v);
Affichage du résultat.
Exercice Ecrire un programme qui demande les deux longueurs des côtés de l’angle droit d’un triangle rectangle et qui calcule la longueur de l’hypoténuse.
Nos connaissances actuelles ne nous permettent pas de faire des programmes utilisant la capacité de l'ordinateur de répéter rapidement et sans erreur beaucoup de calculs. Nous allons donc remédier immédiatement à cela. Chaque structure de contrôle forme une instruction (qui peut donc être utilisée dans une autre structure de contrôle).
Instruction IF – THEN – ELSE La forme la plus simple de l’instruction est : IF condition THEN instructions. Si la condition est remplie alors l’instruction sera exécutée. Voici un exemple simple : PROGRAM exemple_if_then;
VAR a : INTEGER;
BEGIN
Write(‘Entrez un chiffre :’);
Readln(a);
IF a=3 THEN BEGIN Writeln(‘Le chiffre était trois’);
END;
END.
Le programme commence par demander la saisie d’un chiffre. La valeur est attribuée à a. Dans la ligne suivante, il y a une instruction IF … THEN. La condition est a=3. En clair « est-ceque a est égal à 3 ? ». Si c’est la cas, l’instrcution après le THEN (Writeln(‘Le chiffre était trois’);) est exécutée. Si ce n’est pas le cas, il ne se passe rien et le programme se termine. On va améliorer ce programme. On veut que le programme réagisse quand la condition n’est pas réalisée. Pour cela on utilise l’instruction ELSE (sinon) : PROGRAM exemple_if_then_else;
VAR a : INTEGER;
BEGIN
Write(‘Entrez un chiffre :’);
Readln(a);
IF a=3 THEN BEGIN
Writeln(‘Le chiffre était trois’);
END ELSE BEGIN
Writeln(‘Le chiffre n’était pas trois’);
END;
END.
Cette fois si la condition n’est pas réalisée, le programme l’indique en exécutant l’instruction après le ELSE.
Exercice Faire un jeu qui demande de trouver le nombre entre 0 et 10 choisi par l'ordinateur. On utilisera la fonction Random(N) qui renvoie un entier entre 0 et N-1 compris. L'instruction à utiliser est valeur_choisie := Random(11). Si le joueur trouve le nombre, le programme écrira « Gagné ! », sinon, il écrira « Perdu :( ».
Algorithmique au collège - Séance 4 -
La boucle FOR – DO FOR variable : = valeur_de_début TO valeur_de_fin DO instruction;
Une boucle est une structure de contrôle. Cette boucle FOR – DO permet d’indiquer que l’instruction doit être exécuter à plusieur reprise. On maître le nombre de répétition à priori. Exemple : PROGRAM exemple_for_do;
VAR a : INTEGER;
BEGIN FOR a:=1 TO 5 DO BEGIN
Writeln(’ Ceci est un exemple’);
END;
END.
Ce programme affiche : Ceci est un exemple Ceci est un exemple Ceci est un exemple Ceci est un exemple Ceci est un exemple a est appelée l’indice de la boucle. On peut obtenir des valeurs décroissantes de a en remplaçant TO par DOWNTO. On peut utiliser l’indice dans les instructions mais il ne faut jamais modifier l’indice dans les instructions à exécuter !
Exercice Ecrire un programme qui affiche les 25 primers multiples de 17.
La boucle REPEAT – UNTIL REPEAT instruction UNTIL condition;
Cette boucle va répéter l’instruction tant que la condition n’est pas réaliser. Il se peut que la condition ne se réalise pas et alors la boucle se répète indéfiniment. On ne connait pas à priori le nombre de répétitions. Exemple : PROGRAM exemple_repeat_until;
VAR a,mult : INTEGER;
BEGIN
a:=0; (* on initialize la variable indice de boucle à 0 *)
REPEAT Mult:=a*7; (* on cacule la valeur du multiple *)
Writeln (mult); (* on écrit le résultat *)
a:=a+1; (* on incrémente l’indice pour le calcul du multiple suivant *)
UNTIL a*7>=100;
END.
Ce programme va écrire tous les multiples de 7 inéfrieur à 100.
On peut regrouper un ensemble d'instructions sous un même nom. On forme alors un sous-programme ou procédure. On utilise les procédures :
Chaque fois qu'une même suite d'instructions doit être répétée plusieurs fois dans un programme;
Quand une suite d'instructions forme une action globale. Le programme est alors plus clair et les erreurs plus
facilement détectables.
Pour pouvoir utiliser une procédure, il faut d'abord la déclarer. La déclaration des procédures et fonctions se fait après toutes les autres déclarations.
Définir des procédures Il est possible d’écrire et d’utiliser ses propres procédures. L’entête est du type : PROCEDURE Nom_procedure(liste_parametre);
Chaque paramètre doit être typé mais on peut les regrouper par type. Voici une procédure qui va indiquer parmi trois nombes entiers lequel est le plus grand. PROCEDURE Maxde3(a,b,c : integer);
VAR z : INTEGER;
BEGIN
IF a>=b THEN z:=a ELSE z:=b;
IF c>=z THEN z:=c;
Writeln(‘Le plus grand de ces trois nombres est ‘,z); END;
Analyse : VAR z : INTEGER;
Permet de déclarer une variable dite locale qui n’existera et ne sera utilisée que dans la procédure. La valeur de z sera oubliée à chaque nouvel appel de la procédure.
Utiliser une procédure On va maintenant écrire un programme utilisant notre procédure. PROGRAM test;
VAR u,v,t : INTEGER;
PROCEDURE Maxde3(a,b,c : integer);
VAR z : INTEGER; BEGIN
IF a>=b THEN z:=a ELSE z:=b;
IF c>=z THEN z:=c;
Writeln(‘Le plus grand de ces trois nombres est ‘,z);
END;
BEGIN
Write(‘quel est le premier nombre entier ?’);
Readln(u);
Write(‘quel est le second ?’);
Readln(v);
Write(‘quel est le troisième ?’);
Readln(t); Maxede3(u,v,t);
END.
Algorithmique au collège - Séance 5 -
Utiliser des procédures et des fonctions pour réaliser un mini jeu de l’oie. Le programme que nous allons créer sera une version simplifiée du jeu de plateau. Le parcours consiste en 16 cases. Les joueurs commencent à la case 1 et jette le dé à tour de rôle. Dans ce jeu de l’oie, il y aura des cases spéciales :
Case 5 : le joueur qui tombe sur cette case doit retourner à la case 1
Case 9 : retour à la case 6
Case 15 : retour à la case 1 Le but est d’arriver à la case 16. Cela n’est possible qu’en obtenant exactement le nombre de cases requis au dernier tour. Si le dé indique un nombre trop important, il faut reculer. PROGRAM jeu_de_l_oie;
VAR a,b : INTEGER; VAR de : INTEGER;
VAR victoire : INTEGER;
FUNCTION lancer_de():INTEGER;
lancer_de:=random(6)+1; END;
PROCEDURE case_oie(VAR ca : integer;joueur:INTEGER);
BEGIN
IF ca=5 THEN BEGIN ca:=1;
writeln(‘case 5’); writeln(‘Vous êtes tombé dans le puit : retour à la case 1!’);
END;
IF ca=9 THEN BEGIN ca:=6;
writeln(‘case 9’); writeln(‘Un renard !! Fuyez à la case 6!’);
END;
IF ca=15 THEN BEGIN ca:=1;
writeln(‘case 15’); writeln(‘Un chasseur, dommage : retour à la case 1!’);
END;
IF ca>16 THEN BEGIN ca:=16-(ca-16);
writeln(‘Trop loin, on repart en arrière’); case_oie(ca,joueur);
END;
IF ca=16 THEN BEGIN writeln(‘case 16’);
writeln(‘Vous êtes arrive à bon port !’); victoire :=joueur;
END;
END;
BEGIN a:=1;
b:=1;
victoire:=0; REPEAT
IF victoire=0 THEN BEGIN Write(‘Tour du joueur 1 : appuyer sur un touche’);
Readln;
de:=lancer_de(); a:=a+de;
case_oie(a,1); END;
IF victoire=0 THEN BEGIN
Write(‘Tour du joueur 2 : appuyer sur un touche’); Readln;
de:=lancer_de(); b:=b+de;
case_oie(b,2);
END; UNTIL victoire<>0;
Writeln(‘Le joueur ’,victoire,’ a gagné.’); Writeln(‘Appuyez sur un touche’);
Readln;
END.
Dans certains cas, on a besoin dans un programme d’un grand nombre de variables. Nous pourrions penser par exemple ç un programme de gestions de stock. On peut regrouper ces variables dans des tableau de variables.
Déclarer et utiliser un tableau VAR tab : ARRAY [index] OF type;
Voici un premier exemple : VAR table : ARRAY [1..10] OF byte;
déclare un tableau de 10 variables de type byte : table[1], table[2], … ,table[10]. table[1] table[2] table[3] table[4] table[5] table[6] table[7] table[8] table[9] table[10]
On peut toutes les utiliser comme des variables classique et leur donner des valeurs : table[5] := 236;
alloue la valeur 236 à la variable table[5]. Attention : le Pascal renverra une erreur si vous dépassez l’index prévu dans la déclaration : table[25]
n’existe pas dans notre exemple, et onne peut pas redimensionner un tableau. Toutes les variables d’un tableau sont du même type. On peut aussi déclarer des tableaux à pluesieurs dimensions. Il suffit d’adapter l’index : VAR table : ARRAY [1..5,1..6] OF integer;
Déclare un tableau de 5 × 6 variables de type integer. table[1,1] table[2,1] table[3,1] table[4,1] table[5,1] table[1,2] table[2,2] table[3,2] table[1,3] table[1,4] table[1,5] table[1,6]
Chaines de caractères Une chaine de caractère dans le langage courant, on appelle ça un mot. En fait c’est un tableau de type char sur lequel on peut utiliser des fonctions spécifiques.
Ceci est une chaine de 6 caractères.
Déclaration : VAR texte : STRING[nb_char];
nb_char désigne le nombre maximum de caractère dans le texte et vaut au maximum 255. Pour allouer une valeur, il suffit d’écrire : texte :=’Mon texte est joli’;
Le type SRTING est un tableau de caractères à une dimension dont l'élément d'indice zéro contient une variable de type Char et dont le rang dans la table ASCII correspond à la longueur de la chaîne. Dans l’exemple précédant, texte [1] vaut ‘M’ et texte [7] vaut ‘x’.
Quelques opérations sur les chaines de caractères Dans tout la suite, les chaines de caractères ont été préalablement déclarée.
Length(s :STRING) :INTEGER : fonction qui renvoie le nombre de caractères d’une chaine.
texte :=’Mon texte est joli,’;
writeln(length(texte));
affiche 19
P A S C A L
Algorithmique au collège - Séance 6 -
La concaténation : cette opération consiste à recoller ensemble plusieurs chaine de caractères
début :=’Mon texte est joli,’; fin:=’mais il faut le finir’;
texte:=début+fin;
la variable texte est alors égale à ‘Mon texte est joli,mais il faut le finir’.
copy(s:STRING;i,j:INTEGER) : fonction qui copie j charactères de la chaine s à partir de la
position i.
texte :=’Mon texte est joli,’;
res:=copy(texte,3,5);
la variable res est égale à ‘n tex’.
delete(s:STRING;i,j:INTEGER) : procédure qui supprimej charactères de la chaine s à partir de
la position i.
texte :=’Mon texte est joli,’;
delete(texte,5,9);
la variable texte est égale à ‘Mon joli’. (il y a deux espaces).
insert(s1,s2:STRING;i:INTEGER) : procédure qui insere dans s2 la chaine s1 à la position i.
texte :=’Mon texte est joli,’;
don :=’mais il faut le finir’;
insert(texte,don,5);
la variable don est égale à ‘mais Mon texte est joli,il faut le finir’.
Pos(s1,s2) : Fonction qui renvoie sous forme de variable byte la position de la chaîne s1 dans la chaîne-mère s2. Si la chaîne s1 en est absente, alors cette fonction renvoie 0 comme valeur.
Str(x,s) : Procédure qui convertit le nombre (Integer ou Real) x en chaîne de caractère de nom s.
Val(x,s,error) : Procédure qui convertit la chaîne de caractère de nom s en un nombre (Integer ou Real) x et renvoie un code erreur error (de type integer) qui est égale à 0 si la conversion est possible.
Exercice Voici un texte (à copier) : « Or donc il advint que la comtesse qui se baigna dans le sang revigorant d'une centaine de vierges, fut enterrée vive. Son château théâtre de tant de cruautés, tomba rapidement en ruines. Tout ce qu'il en reste est une tour solitaire. » Ecrire un programme qui compte le nombre de caractères de ce texte puis un autre qui l’affiche en allant à la ligne tous les 30 caractères.
En Pascal, les images affichées le sont à base de points. De base, le Pascal n’en est pas capable. Pour remédier à ce problème, il est possible d’ajouter à sn programme des banques de fonctions prédéfinies appelées « unités » . L’unité que nous allons utiliser s’appelle « jbbm ». Elle s’utilise avec l’unité « crt ». Il suffit d’écrire en début de programme : USES crt,jbbm;
Ecran, résolution et pixels Pour chaque image affichée à l’écran, l’ordinateur utilise une division en 200 lignes de 320 points (appelés pixels) chacune. Chaque pixel est donc repéré par ses coordonnées :
L’origine du repère se situe en haut à gauche. La première coordonnée repère la position horizontale et la seconde la position verticale. Les coordonnées sont des nombres entiers.
Palette et couleur Pour afficher un point, il suffit de lui donner une couleur. La couleur est un nombre qui se referre à un index dans la palette de couleur. La palette est composée de 256 couleurs (de 0 à 255) qu’on pourra configurer à sa guise.
Un premier exemple PROGRAM test;
USES crt,jbbm;
VAR x,y : INTEGER;
col : byte;
BEGIN
Write(‘x=’);readln(x);
Write(‘y=’);readln(y);
Write(‘numéro de la couleur : ‘);readln(col); Setmcga;
Pix(x,y,col,vga);
Readln;
END.
Algorithmique au collège - Séance 7 -
Analyse : x désigne la première coordonnée et y la seconde. Col désigne le numéro de la couleur. Attention il n’y a pas de teste de validité. Setmcga;
Indique que l’on passe en mode graphique. Pix(x,y,col,vga);
Affiche un point de coordonnées (x,y) et de couleur col à l’écran. A la fin du programme, le pascal repasse automatiquement en mode texte et efface ce qui a été dessiné.
Les procédures et fonctions graphiques de l’unité jbbm Les procédures : setMCGA : passage en mode MCGA : 320*200*256 couleurs settext : passage en mode texte cls(col:byte;vga) : efface l'écran avec une couleur pix(x,y:integer;col:byte;vga) : affiche un pixel en couleur synchro : attend la fin d'un rafraîchissement de l'écran line(x1,y1,x2,y2:integer;col:byte;vga) : trace une ligne entre les pixels(x1,y1) et (x2,y2) ecrirecol(col,r,v,b:byte) : modifie une couleur de la palette Les fonctions couleur(x,y,vga):word : lit la couleur d'un pixel
Exercices Ecrire un programme qui affiche le dessin suivant :
Les nombres entre parenthèses sont les coordonnées des sommets.
Ecrire une fonction qui permet de tracer un rectangle avec comme paramètres les coordonnées du sommet supérieur gauche, la longueur, la largeur et la couleur du trait. L’utiliser pour tracer 4 rectangles de couleurs différentes. Ecrire Ecrire une fonction qui permet de tracer un rectangle plein avec comme paramètres les coordonnées du sommet supérieur gauche, la longueur, la largeur et la couleur du remplissage. L’utiliser pour tracer 4 rectangles de couleurs différentes.
Corrections : Séance 1
Séance 2
