Algorithme et Programmation

Certains voient, ` a tort, dans lordinateur une machine pensante et intelligente, capable de r esoudre bien des probl` emes. En fait, celui-ci ne serait capable de rien si quelquun (le programmeur en loccurence) ne lui avait fourni la liste des actions ` a ex ecuter. Cette description doit etre faite de mani` ere non ambig ue car il ne faut pas sattendre ` a la moindre interpr etation des ordres fournis. Ils seront ex ecut es de mani` ere purement m ecanique. De plus, les op erations el ementaires que peut ex ecuter un ordinateur sont en nombre restreint et doivent etre communiqu ees de fa con pr ecise dans un langage quil comprendra. Le probl` eme principal du programmeur est donc de lui d ecrire la suite des actions el ementaires permettant dobtenir, ` a partir des donn ees fournies, les r esultats escompt es. Cette description doit etre pr ecise, doit envisager le moindre d etail et pr evoir les diverses possibilit es de donn ees. Cette marche ` a suivre porte le nom dalgorithme dont lEncyclopaedia Universalis donne la d enition suivante : Un algorithme est une suite nie de r` egles ` a appliquer dans un ordre d etermin e` a un nombre ni de donn ees pour arriver, en un nombre ni d etapes, ` a un certain r esultat, et cela ind ependamment des donn ees. En fait, la notion dalgorithme est tr` es ancienne, et est ind ependante de linformatique et des machines : les marchands, par exemple, avaient recours ` a certains algorithmes pour calculer des int er ets etc ... De m eme, au vu de la d enition pr ec edente, une recette de cuisine est un algorithme, tout comme une notice de montage dun meuble en kit. Dans ces derniers cas, on voit bien la n ecessit e dun algorithme clair (compr ehensible par tous), le plus g en eral possible (pour r epondre au plus de cas possibles) et rapide (ecace). Structure dun algorithme Structure dune recette de cuisine : on commence par enum erer tous les ingr edients n ecessaires ; puis on d ecrit les etapes successives ` a faire. Enn, si lalgorithme est bon, un merveilleux gateau sort du four ! En fait, tout algorithme se d ecompose en 3 parties. La premi` ere partie concerne les entr ees : on liste toutes les donn ees n ecessaires. La deuxi` eme partie regroupe toutes les instructions ; et la troisi` eme est la sortie ou r esultat. Programmation Un programme est la traduction dun algorithme en langage compr ehensible par la machine. Nous ne verrons que le langage Turbo-Pascal.

Structure g en erale dun programme en Turbo-Pascal

1. en-t ete du programme 2. d eclaration eventuelle des constantes, des types et des variables 3. d eclaration eventuelle des proc edures et fonctions 4. corps du programme Explications succintes : 1. syntaxe : PROGRAM nom du programme ; 2. il faut d eclarer tous les objets utilis es dans le corps du programme : cest une exigence du langage TurboPascal. syntaxe : CONST a=2; x=3.5; VAR i,k,n : INTEGER; les entiers prennent leurs valeurs dans [[32768, 32767]] x,a,b : REAL; x,a,b sont des r eels test : BOOLEAN; variable de type bool eenne : sa valeur est true ou false. T : ARRAY [1..10] of integer ; tableau de 10 cases ` a coecients entiers mat : ARRAY[1..3,1..3] of real ; tableau ` a 3 lignes 3 colonnes (matrice carr ee dordre 3) ` a coecients r eels. La d eclaration des types sera vue ult erieurement. 1

3. les fonctions et proc edures seront vues au second semestre : ces sous-programmes permettent de structurer davantage un programme. 4. cest le corps du programme : on liste les instructions ` a ex ecuter. Cette partie est donc la traduction de lalgorithme proprement dit. syntaxe : BEGIN instructions ; . . . END. Sauf mention contraire, chaque ligne de commande se nit par un ;. On peut ajouter des commentaires au programme pour am eliorer la lisibilit e en expliquant certaines instructions ou noms de variable. Ces commentaires peuvent etre ins er ees nimporte o` u du moment quils sont plac es entre accolades : { blablabla }

1
1.1

Variables et actions el ementaires

Les variables

En informatique, une variable est une case m emoire, r eserv ee pour stocker la future valeur de cette variable (valeur qui peut etre modi ee au cours du programme). Une variable doit avoir un nom (ou identicateur), ainsi quun type (entier, r eel etc...), qui d enit la taille de la case m emoire. Ces deux attributs sont d eclar es simultan ement dans la partie 2. : syntaxe : VAR i :INTEGER ; note :REAL ; Remarque sur les identicateurs : vous pouvez choisir nimporte quel mot (non r eserv e bien s ur), du moment quil ne contient ni espace, ni accents, ni apostrophes. Conseil : choisir un mot ou une lettre evocatrice ! Puis dans le corps du programme, une variable doit etre initialis ee. Deux moyens sont possibles : par lecture ex : writeln( ecrire les valeurs de a et b); quand le programme s ex ecute, on voit appara tre ` a l ecran : ecrire les valeurs de a et b. readln(a,b); les deux valeurs alors ecrites par lutilisateur (s epar ees par un espace ou un retour ` a la ligne) sont aect ees aux variables a et b. par aectation ex : x :=1 ; {x re coit la valeur 1} ou si a et b ont et e initialis ees comme pr ec edemment, x :=(a+b)/2 aecte ` a x la valeur (a+b)/2. Attention : 1. si lon ecrit a:=b, il faut que les variables a et b soient de m eme type. 2. Ne pas confondre := avec le = r eserv e aux donn ees constantes et au symbole de comparaison.

1.2

Op erations el ementaires

Ces op erations d ependent du type des objets (variables ou constantes). Attention, les op erations sont ` a eectuer entre des objets de m eme type ! Op erateurs et fonctions arithm etiques op erateurs entr ee(s) sortie commentaires +-* r eel/entier r eel /entier op erations el ementaires / r eel /entier r eel le type de sortie peut donc etre di erent du type de lentr ee div mod entier entier quotient et reste de la division euclidienne : 37 div 5 donne 7 et 37 mod 5 donne 2. exp, ln, sqrt r eel/entier r eel sqrt est la racine carr ee sqr r eel/entier r eel/entier carr e trunc r eel entier partie enti` ere abs r eel/entier r eel/entier valeur absolue 2

Op erateurs relationnels =, <> pour =, <, >, <= pour , >= pour . Les variables dentr ees sont de type entier/r eel ; la variable de sortie est de type bool een. Ces op erations sont principalement utilis es dans les instructions conditionnelles (que lon reverra ult erieurement) : if op erateur then instructions (else instructions) while op erateur do instructions repeat instructions until operateur Op erateurs logiques Il y en a 3 : not, or et and ; qui ne seront utilis es que dans les instructions conditionnelles ci-dessus. Par exemple : (x < 1) AND (x > 1) ou encore (x > 0) OR (y = 0), peuvent etre une condition du if.

2
2.1

Instructions conditionnelles
instructions

Une instruction est dite simple si elle se r eduit ` a une seule commande : writeln(bonjour) ou s:=0; Sinon, linstruction est dite compos ee : on peut aussi parler de groupe dinstructions.

2.2

if then else

Cette instruction r epond ` a lattente : Si une condition est vraie (par exemple x = 0), alors on veut eectuer une certaine instruction (par exemple, diviser par x) et sinon, on en eectue une autre. La syntaxe est la suivante : instructions A ; IF condition THEN BEGIN instructions B ; END ELSE BEGIN instructions C ; END; instructions D ; Remarques : i. Si les instructions B ou C sont simples, le BEGIN END; correspondant est inutile. ii. Le ELSE est facultatif ; mais il ne doit pas etre pr ec ed e imm ediatement dun ;. Exemples de condition : x = 0 ou x >= 10 o` u x est une variable d enie pr ec edemment. Les conditions peuvent etre compos ees : par exemple (0 < x) AND (x <= 1) (qui signie 0 < x 1). Attention : ne pas confondre x := 3 et x = 3 lorsque x est une variable. x := 3 est une aectation : elle correspond ` a linstruction donner ` a x la valeur 3. x = 3 est une condition bool eenne (proposition qui est vraie au fausse) : elle correspond ` a la question x est-il egal ` a 3 ?. Ces conditions bool eennes ne seront pr esentes que dans les instructions conditionnelles (if then else) ou les boucles conditionnelles (while et repeat until).
A

vrai condition

faux

3
3.1

Boucles it eratives
Boucle FOR

Cette instruction semploie pour r ep eter une suite dinstructions n fois, lorsque n est connu ` a lavance. La syntaxe est la suivante :

instructions A ; FOR i := n1 TO n2 DO BEGIN instructions B ; END; instructions C ; Remarques : i. Le groupe dinstructions B est eectu e une premi` ere fois avec i = n1 , une deuxi` eme avec i = n1 + 1,...., puis une derni` ere avec i = n2 . Attention la variable compteur i doit etre d eclar ee en 2 ! ii. n1 et n2 sont deux nombres entiers ou alors variables de type entier, d eclar ees et initialis ees. iii. Si linstruction B est simple le BEGIN END; correspondant est inutile. iv. Si n1 > n2 , le groupe dinstructions B nest pas ex ecut e. Variante : Si lon veut aller de n2 ` a n1 dans lordre d ecroissant, la syntaxe devient : FOR i := n2 DOWNTO n1 DO .

3.2

Boucles conditionnelles

Par opposition ` a linstruction r ep etitive FOR, les instructions WHILE et REPEAT semploient d` es que lon ne conna t pas ` a lavance le nombre dit erations ` a eectuer. 3.2.1 Boucle WHILE

On r ep ete une suite dinstructions tant quune certaine condition est vraie. La syntaxe est la suivante :
A

instructions A ; WHILE condition DO BEGIN instructions B ; END; instructions C ;

vrai

faux condition

C Remarques : i. Les instructions B peuvent ne pas etre ex ecut ees du tout (si d` es le d epart la condition est fausse) ii. Si linstruction B est simple, le BEGIN END ; correspondant est inutile iii. Attention de bien vous assurer, avant de lancer le programme, que la condition devient fausse au bout dun certain temps. Sinon, le programme ne sarr etera jamais.

3.2.2

Boucle REPEAT

On r ep ete un groupe dinstructions jusqu` a ce quune condition soit vraie. La seule di erence avec la boucle WHILE est que dans la boucle REPEAT les instructions B sont ex ecut ees avant de tester la condition donc sont ex ecut ees au moins une fois. La syntaxe devient : A instructions A ; REPEAT instructions B ; UNTIL condition ; instructions C ;

faux

condition

vrai

Remarques : C i. REPEAT UNTIL permet de d elimiter linstruction B, donc quelle soit simple ou compos ee, il ny a pas besoin de BEGIN END;. ii. Attention de bien vous assurer, avant de lancer le programme, que la condition devient vraie au bout dun certain temps : sinon le programme ne sarr etera jamais. 4

4
4.1

Fonctions et Proc edures

Notion de sous-programme

Il peut arriver que lon doive utiliser une m eme s equence dinstructions ` a di erents endroits dun programme. Il est alors judicieux de cr eer un sous-programme (fonction ou proc edure) dont le code sera d eni une fois pour toutes dans l etape 3, et que lon appellera dans le corps du programme aux di erents endroits souhait es. evite ainsi des r ep etitions de code. Avantage : le corps du programme est plus court et plus lisible puisque lon Exemple : le calcul de n! n ecessite le calcul de 3 factorielles ; on pourra ecrire une fonction factok !(n k )! rielle en amont, et ensuite lappeler 3 fois.
n k

Exemple bis : dans la dichotomie, on fait appel ` a une fonction ` a chaque etape. Dans notre exemple cest la fonction f (x) = ex 2 qui est facile ` a ecrire ` a chaque fois. Mais si la fonction plus complexe, il est n ecessaire de cr eer une fonction turbo-pascal en amont. Un sous-programme a la m eme structure quun programme mais le END du corps du sous-programme est suivi dun ; et non dun . Il faut d eclarer ces sous-programmes dans l etape 3., juste avant le corps du programme. Toutes les variables utilis ees dans un sous-programme doivent etre d enies soit comme des param` etres dentr ee soit comme des variables locales (les variables du programme sont appel ees variables globales). Mais lappel du sous-programme se fait dans le CORPS du programme ( etape 4). Il y a deux sortes de sous-programmes : les fonctions et les proc edures.

4.2

Les fonctions

Une fonction est un sous-programme qui fournit un r esultat num erique ` a partir des donn ees quon lui apporte (les param` etres dentr ees) : la notion de fonction en Turbo-Pascal est assez proche de la notion de fonction en math ematiques. Une fonction se d eclare comme suit : FUNCTION Nom-de-la-fonction (Nom-du-param` etre : Type-du-param` etre) : Type-sortie ; VAR D eclaration des eventuelles variables LOCALES (ou constantes via CONST) ; BEGIN Corps de la fonction (liste des instructions) ; Nom-de-la-fonction := Valeur-sortie ; END ; Remarques : Une fonction ne peut avoir en sortie quun r eel ou un entier. Il peut y avoir plusieurs param` etres dentr ees dans une fonction. Ils seront alors s epar es par un ; dans la d eclaration mais par une , lors de lappel de la fonction dans le corps du programme. exemple : function nom(n:integer ; x:real):real; ou... Exemple 1 : PROGRAM fonction; FUNCTION ffff(x : REAL) :REAL ; BEGIN ffff := 3*sqr(x)+2; END; BEGIN write(ffff(3)); END. Exemple 2 : a) ecrire la fonction Turbo-pascal factorielle, qui ` a un entier positif n associe n!. b) lint egrer dans un programme qui demande deux entiers n et k n ` a lutilisateur, et qui renvoie PROGRAM ex2; VAR k,n:INTEGER; FUNCTION factorielle (N : INTEGER) : INTEGER ; VAR i,F : INTEGER ; BEGIN F:=1; 5

n k

FOR i:=1 TO N DO F:=F*i; factorielle :=F; END; BEGIN write(Entrer deux entiers n et k);readln(n,k); write(factorielle(n)/(factorielle(k)*factorielle(n-k)); END.

4.3

Les proc edures

Contrairement aux fonctions, la proc edure ne fournit pas un r esultat mais cr ee une action ou une suite dactions (instructions) : on utilisera les proc edures principalement lorsquon manipulera des tableaux (matrices ou autres). En eet, une fonction ne permet pas de modier un tableau puisque son but est de renvoyer un nombre. Sa syntaxe est analogue ` a la syntaxe dune fonction : PROCEDURE Nom-de-la-proc edure ( VAR Nom-du-param` etre : Type-du-param` etre) ; VAR D eclaration des eventuelles variables LOCALES (ou constantes via CONST) ; BEGIN Corps de la proc edure (liste des instructions) ; END ; Remarque : il existe une variante dans len-t ete de la proc edure PROCEDURE Nom-de-la-proc edure (Noms-param` etres : Type-param` etres) ; Cette variante sans VAR sera utilis ee lorsquon ne voudra pas que le param` etre dentr ee puisse etre modi e par la proc edure. On dit alors que le param` etre dentr ee passe par valeur (et non par variable) : ce param` etre dentr ee peut etre juste un nombre (et non n ecessairement une variable). Exemple : a) Ecrire une proc edure qui echange le contenu de 2 variables. b) Lint egrer dans un programme qui demande deux r eels x1 et x2 ` a lutilisateur et qui les trie dans lordre croissant. PROGRAM exemple; VAR x1,x2:REAL; PROCEDURE echange(VAR a,b : REAL); VAR aux : REAL; BEGIN aux := a; a:=b; b:=aux; END; BEGIN write(donner deux r eels); readln(x1,x2); IF x1 > x2 then echange(x1,x2); END.

Simulation dexp eriences al eatoires

Introduction : Supposons que lon ait une pi` ece truqu ee dont on veut d eterminer la probabilit e p dobtenir face. Le moyen exp erimental ` a notre disposition est de lancer un tr` es grand nombre de fois la pi` ece, par exemple nf appel e fr equence dapparition n = 1000, et de compter le nombre doccurences face : nf . Alors, le rapport n de face, est une approximation de p, dautant meilleure que n est grand. Plus pr ecis ement, si lon r ealise n r ep etitions ind ependantes dune m eme exp erience al eatoire de d epart, la fr equence de r eussite dun certain ev enement tend vers la probabilit e de cet ev enement lorsque n +. Donc pour avoir une valeur approch ee de cette probabilit e, il faut eectuer un grand nombre de fois la m eme exp erience al eatoire, ce que permet loutil informatique en tr` es peu de temps ! ! Il sut que le langage utilis e puisse cr eer du hasard : pour cel` a, il doit poss eder un g en erateur de nombres al eatoires.

Syntaxe : Pour activer le g en erateur de nombres pseudo-al eatoires de Turbo-Pascal, il faut ins erer dans le d ebut du corps du programme, la commande Randomize ;. Ensuite, deux fonctions sont pr ed enies dans Turbo-Pascal : i. random ; sans argument retourne un r eel compris entre 0 et 1. ii. random(n); o` u n N , retourne un entier (parmi les n) compris entre 0 et n 1 avec equiprobabilit e. Autrement dit, cette fonction random (n) permet de simuler la loi uniforme sur {0, 1, 2, . . . , n 1}.

Les tableaux

Utilit e des tableaux : Pour stocker des donn ees : dans la feuille de TP 8, on stockera les di erents r esultats dune exp erience al eatoire dans un tableau, avant de les analyser. Pour travailler sur des matrices ou des polyn omes.

6.1
6.1.1

D eclarer un tableau
Tableau ` a une entr ee

Avant de pourvoir utiliser un tableau, il faut le d eclarer comme variable : VAR tableau : ARRAY[deb..fin] OF (type) ; Dans cette syntaxe, deb et fin sont de type integer, sous la contrainte deb fin. La variable tableau est alors un tableau compos e de colonnes num erot ees de deb ` a fin. Ce tableau comportera donc fin-deb+1 cases, remplies par des el ements de type type. Chaque case du tableau est alors une variable, identi ee par tableau[i]. Au d epart, le tableau est vide : il faudra donc penser ` a initialiser toutes les cases du tableau avant de lutiliser ! Exemple : Les coordonn ees dun point A du plan peuvent etre repr esent ees par le tableau suivant : VAR coordA : ARRAY[1..2] OF REAL ; coordA[1] donne labscisse du point A et coordA[2] lordonn ee. Exemple : le polyn ome P (x) = 1 + 2x + 4x3 + 5x6 3x9 , en tant que polyn ome de degr e inf erieur ou egal ` a 10, peut etre repr esent e par le tableau 1 2 0 4 0 0 5 0 0 -3 0 Il sera donc d eclar e par : VAR P : ARRAY[0..10] OF INTEGER ; 6.1.2 Tableau ` a double entr ees

Exemple : Une matrice A de M2,3 (R) sera d eclar ee par la syntaxe VAR A : ARRAY[1..2,1..3] OF REAL ; tandis quune matrice B de M8,5 (R) ` a coecients entiers le sera par VAR B : ARRAY[1..8,1..5] OF INTEGER ;

6.2

Cr eer un type tableaux

Rappel : la syntaxe dune fonction comme dune proc edure demande la connaissance du type du param` etre dentr ee. Par exemple, FUNCTION f (x : REAL) : INTEGER ; Pour pouvoir appliquer des fonctions ou des proc edures ` a un tableau, il faut donc d eclarer le type de ce tableau en amont. La d eclaration dun nouveau type se fait juste avant la d eclaration des variables ( etape 2 dans la structure g en erale dun programme). d eclarations des types : Ensuite, se fait la d eclaration des variables : TYPE polynome = ARRAY[0..10] OF real ; VAR P,Q,R : polynome ;

D` es que lon a d eni un tel type polynome, on peut appliquer une fonction ou une proc edure ` a un polynome. Attention de garder en m emoire quune fonction ne pourra jamais renvoyer un polyn ome : sa sortie ne peut etre quun r eel (ou un entier). Mais une proc edure pourra, par son action, changer la variable polyn ome dentr ee. Exemple : Lorsque lon souhaitera travailler commod ement avec plusieurs matrices de M3 (R), et cr eer des fonctions et proc edures sy rapportant, on proc edera en d eclarant : TYPE matrice = ARRAY[1..3,1..3] OF real ; VAR A, B, C : matrice ; 7

6.3

Op erations sur les tableaux

La seule op eration globale possible sur les tableaux est laectation. Si R et A sont deux tableaux de m eme dimension et type de contenu, la commande R:=A; remplace le contenu du tableau R par celui du tableau A. Toutes les autres op erations portant sur les tableaux se font case par case, donc en utilisant des boucles. Ce d efaut engendre souvent des temps de traitement importants, en particulier pour les tableaux de grande taille. Rappel : toutes les cases dun tableau sont des variables donc doivent etre initialis ees par lecture ou aectation. Tableaux ` a 1 dimension D eclarer le tableau : VAR T : ARRAY[1..50] of REAL; D eclarer le type puis une variable de ce type : TYPE tab = ARRAY[1..50] of REAL; VAR T:tab; Initialiser la 15-i` eme case de T ` a0: T[15]:=0 ; Initialiser la 18-i` eme case de T ` a une valeur entr ee par lutilisateur : WRITELN(Entrer la valeur de la case 18); READLN(T[18]); Acher la valeur de la case 25 du tableau : WRITELN(T[25]); Initialiser tout le tableau T ` a0 FOR k:=1 TO 50 DO T[k]:=0; Initialiser tout le tableau T ` a des valeurs entr ees par lutilisateur : FOR k:=1 TO 50 DO BEGIN WRITELN(Entrer la valeur de la case ,k); READLN(T[k]); END; Acher tout le tableau : FOR k:=1 TO 50 DO WRITELN(T[k]); Tableaux ` a 2 dimensions D eclarer le tableau : VAR U : ARRAY[1..50,1..40] of REAL; Initialiser la case situ ee ` a la 11-i` eme ligne et 23-i` eme colonne de U ` a0: U[11,23]:=0 ; Initialiser la case situ ee ` a la 8-i` eme ligne et 27-i` eme colonne de U ` a une valeur entr ee par lutilisateur : WRITELN(Entrer la valeur de la case situ ee ligne 8 colonne 27); READLN(U[8,27]); Acher la valeur de la case situ ee ` a la ligne 25, colonne 17 du tableau : WRITELN(U[25,17]); Initialiser tout le tableau U ` a0: FOR i:=1 TO 50 DO FOR j:=1 TO 40 DO U[i,j]:=0; Initialiser tout le tableau U a ` des valeurs entr ees par lutilisateur : FOR i:=1 TO 50 DO FOR j:=1 TO 40 DO BEGIN WRITELN(Entrer la valeur ligne ,i, colonne ,j); READLN(U[i,j]); END; Acher tout le tableau : FOR i:=1 TO 50 DO BEGIN FOR j:=1 TO 40 DO WRITELN(U[i,j]); WRITELN; END; 8 (autre exemple : VAR T : ARRAY[2..8] of INTEGER;)