TD 1

Exercice 1

Faire   un   programme   qui   calcul   les   racines   d'un   trinôme   du   second   ordre.   Autrement   dit,   faire   un 
programme   qui   demande   a , b , c   et   qui   donne   les   solutions   x 1, x 2   de   l'équation 
aX 2bXc=0 .

Correction :
On commence par écrire les formules mathématiques pour résoudre ces équations :
−b− D −b  D
D=b2−4 a c , si  D0 les solutions sont :  x 1 = , x 2= .
2a 2a
S'en suit le programme suivant :

PROGRAM trinôme;
VAR
  a,b,c,D,x1,x2 : REAL;
BEGIN
  writeln('Resolution de aX^2+bX+c=0');
  writeln('Donnez a b et c');
  readln(a,b,c);
  D:= (b*b) – (4*a*c);
  x1:= (­b­sqrt(D))/(2*a);
  x2:= (­b+sqrt(D))/(2*a);
  writeln('Premiere solution : x1=',x1);
  writeln('Deuxieme solution : x2=',x2);
  readln;
  END.

Si   la   valeur   de   D   est  négative,   le   trinôme   n'a  pas   de   solutions   réelles   Dans   ce   programme,   cela 
provoquera   une   erreur   a   l'exécution   :   A   noter   que   ces   erreur   sont   très   différente   des   erreurs   de  
compilation ! Une erreur de compilation a lieu lorsque l'ordinateur ne comprend pas votre programme,
et il n'essaye donc même pas de l'exécuter Une erreur a l'exécution correspond généralement a un  
calcul impossible (racine carre d'un réel négatif, division par zéro) ou que l'utilisateur donne une  
entrée dans un mauvais format (par exemple, du texte lorsque le programme attend un entier).

Exercice 2

Faire un programme qui calcul le produit de deux nombres complexes. Le Turbot Pascal n'offrant pas 
de type pour représenter le complexe, on représentera les complexes en utilisant deux réels  a , b  en 
forme cartésienne :  x=ab i .

Correction :
On commence par écrire les formules mathématiques pour résoudre ces équations :
Soit   z=z 1 ∗z 2 le produit que l'on veut calculer. On pose   z=ab i , z 1=a 1b 1 i , z 2=a 2b 2 i avec 
a , b , a 1 , b1, a2, b 2 des réels
z=z 1 ∗z 2=a 1b 1 ia 2b2 i =a 1 a 2a1 b 2 ib1 a 2 ib 1 b2 i 2=a1 a 2−b 1 b2  a1 b2 b 1 a 2 i .
On a donc  a=a1 a 2−b 1 b2 , b=a1 b 2a 2 b1

S'en suit le programme suivant :

PROGRAM produit_complexe;
VAR
  a,b,a1,b1,a2,b2 : REAL;
BEGIN
  writeln('Produit de deux complexes');
  writeln('Donnez le premier complexe');
  readln(a1,b1);
  writeln('Donnez le deuxieme complexe');
  readln(a2,b2);
  a:=a1*a2 – b1*b2;
  a:=a1*b2 + a2*b1;
  writeln('le produit est : z= ',a,' + ',b, ' i');
  readln;
  END.

On montre par cet exemple comment faire des calculs sur des objets mathématiques plus compliques  
que ceux présent de base dans le langage. Cette approche est très importante pour certains algorithmes  
que nous verrons plus tard.

Les Boucles FOR

Les boucles FOR permettent de répéter une série d'instruction un certain nombre de fois. Jusqu'ici, 
chaque instruction tapée faisait faire une instruction a l'ordinateur : l'intérêt par rapport au calcul a la 
main est donc assez limite, si ce n'est qu'on peut exécuter le programme plusieurs fois avec différente 
valeurs. Les boucles permettront donc de démultiplier le travail effectue par l'ordinateur par rapport au 
travail fourni par le programmeur.

Pour réaliser un boucle FOR, il faut avant tout avoir défini un compteur, qui devrai toujours être un 
variable de type INTEGER. Les instructions a l'intérieur de la boucles seront répété pour chaque valeur 
du compteur entre la borne de début et la borne de fin. La syntaxe est la suivante :

PROGRAM exemple_FOR;
VAR
  i : INTEGER;
BEGIN
  writeln('Bonjour, je vais bavarder, et même beaucoup bavarder');
  FOR i:=1 to 300 do BEGIN
    write('bla');
    END;
  writeln('Voila, j''ai fini de bavarder');
  readln;
  END.

On notera la présence de BEGIN et END. Ceux ci servent a délimiter la boucle : les instructions qui 
seront répétés sont celles comprise entre le BEGIN et le END qui suivent le FOR, tout comme le 
premier BEGIN et le dernier END définissent le début et la fin du programme. C'est ce que l'on appelle 
un bloc. L'intérêt est donc de pouvoir choisir spécifiquement les choses a répéter : seul l'instruction 

write('bla');

sera répété ici, pas le message d'introduction, ni de conclusion. Ces blocs pourront se combiner de 
différentes façon, soit successivement, soit les uns a l'intérieur des autres.
De plus a chaque itération de la boucle, la valeur du compteur (ici I) augmente de 1. Cela permet de 
savoir a quel étape nous en somme, nous verrons un exemple de l'utilisation de I dans les exercices 3 et 
4.

Enfin, si il y a une seule instruction a répéter, il est inutile d'utiliser BEGIN et END : le programme 
suivant fait la même chose que le précédent

PROGRAM exemple_FOR2;
VAR
  i : INTEGER;
BEGIN
  writeln('Bonjour, je vais bavarder, et même beaucoup bavarder');
  FOR i:=1 to 300 do write('bla');
  writeln('Voila, j''ai fini de bavarder');
  readln;
  END.

A la fois pour vous, et pour la personne qui relit votre programme, 

Assignation, reassignation

Nous avons vu en cours l'instruction permettant de stocker un valeur dans une variable :

x:=a+b­c*3;

Cela differt légèrement de la définition mathématique de l'hyalite : si plus tard dans le programme on 
effectue l'assignation :

x:= 7;

nous n'auront pas pour autant l'hyalite a+b­3c = 7. L'assignation correspond donc a l'idée d'un stockage 
temporaire :  x <­ 7;

Il n'y a donc pas de problème a effectuer une instruction du genre : x:= x+3; qui augmente de 3 la 
valeur de x, ou  :y:= y*2 ; qui multiplie y par 2.
Exercice 3

Faire un programme qui demande un entier N, puis qui écrit tous les entiers de 1 a N.

Correction :

PROGRAM de_un_a_N;
VAR
N,i : INTEGER;
BEGIN
  WRITELN('Enumeration des entiers de 1 a N');
  WRITELN('Entrez N');
  READLN(N);
  FOR i:=1 to N do BEGIN
    WRITELN(i);
    END;
  WRITELN('Voila !');
  readln;
  END. 
   
Exercice 4

Faire un programme qui demande un entier N, puis qui calcul la somme des entiers de 1 a N.

Correction :
Comme précédemment il nous faudra deux variables : N pour savoir jusqu'où va la somme, i pour le  
compteur de la boucle. Il nous faudra une variable supplémentaire, x pour calculer la somme pas a  
pas. 
L'idée ici est de voir x comme un tiroir vide, dans lequel on va ajouter 1 bille, puis 2 billes, puis 3  
billes, etc... Cela correspond bien a l'idée d'une boucle, ou a chaque passage on ajoute la valeur du  
compteur i. Une autre flacon plus mathématique est de voir cela comme une suite récurrente : si l'on  
note  x i la valeur de x lors de la i­ème entrée dans la boucle FOR, on calcul la somme par la suite  
récurrente :  x 0 =0 , x i=x i −1 i ,le résultat final étant  x N .

PROGRAM Somme;
VAR
N,i,x : INTEGER;
BEGIN
  WRITELN('Somme des entiers de 1 a N');
  WRITELN('Entrez N');
  READLN(N);
  x:=0;
  FOR i:=1 to N do BEGIN
    x:=x+i;
    END;
  WRITELN(x);
  readln;
  END. 
  Le deuxième point de vue permet de généraliser la méthode a d'autres problèmes similaire: si l'on 
cherche  a   calculer   la  fonction   factorielle   ( n !=1 ∗2∗3∗n )  on  peux   la  calculer   par  récurrence 
x 1 =1 , x i= x i−1 ∗i , avec alors  n !=x n . On a donc le programme suivant :

PROGRAM factorielle;
VAR
N,i,x : INTEGER;
BEGIN
  WRITELN('factorielle N');
  WRITELN('Entrez N');
  READLN(N);
  x:=1;
  FOR i:=1 to N do BEGIN
    x:=x*i;
    END;
  WRITELN(x);
  readln;
  END.