Ecrire un programme qui lit une valeur et affiche sa table de multiplication (on se limitera aux 12 premiers termes).

Solution : Voir le fichier Multi1.pas :

program multi1;
var
  i: integer;
  nombre: integer;
begin
  write('Entrez un nombre: ');
  readln(nombre);
  for i := 1 to 12 do
    writeln(nombre * i);
  readln;
end.

Faire une variante du programme précédent qui affiche la table de multiplication de tous les chiffres compris entre 2 et 9 (inclus).

Note :

• Pensez à laisser un espace entre deux tables de multiplication.

Solution : Voir le fichier Multi2.pas :

program multi2; 
uses
  crt; 
var 
  i, j: integer;
begin 
  clrscr; (*Pour nettoyer l'écran. On a alors besoin d'utiliser l'unité crt*)
  or j := 2 to 9 do 
    begin 
      for i := 1 to 12 do 
        writeln(j * i); 
      writeln 
    end;
  readln;
end.

Faire une autre variante qui affiche chaque table sur une ligne.

Solution : Voir le fichier Multi4.pas

program multi4;
uses crt;
var
  i, j: integer;
begin
  clrscr;
  for j := 2 to 9 do
  begin
    for i := 1 to 12 do
      write(j * I: 5);
        (*Les nombres sont écrits avec une plage de 5 caractères et justifiés à droite*)
    writeln
  end;
 
  readln;
end.

En déduire un programme qui affiche la table par colonne...

Solution : Voir le fichier Multi3.pas

program multi3;
uses crt;
var
  i, j: integer;
begin
  clrscr;
  for j := 1 to 12 do
  begin
    for i := 2 to 9 do
      write(j * i: 8);
    writeln;
  end;
 
  readln;
end.

Reprendre le programme Switch3.pas et afficher le menu jusqu'à ce qu'une entrée correcte soit entrée.
Note :

• Consultez l'aide sur la fonction repeat

Solution : Voir le fichier Repeat.pas

program switch1;
uses crt;
var
  valeur: integer;
begin
  clrscr;
  repeat
    writeln('1. Effectuer une multiplication');
    writeln('2. Effectuer une addition');
    writeln('3. Effectuer une soustraction');
    writeln('4. Effectuer une division');
    readln(valeur);
 
    case valeur of
      1: writeln('Vous avez choisi la multiplication');
      2: writeln('Vous avez choisi la addition');
      3: writeln('Vous avez choisi la soustraction');
      4: writeln('Vous avez choisi la division');
    else
      writeln('Choix incorrect');
    end;
    writeln;
  until valeur < 5;
 
  readln;
end.

Remarques :

• La condition de la boucle repeat, valeur<5 en l'occurrence, aurait pu être remplacée soit par les conditions ((valeur>=1) and (valeur<=4)) soit par ((valeur=1) or (valeur=2) or (valeur=3) or (valeur=4)).
  
  
• Consultez l'aide sur les fonctions logiques and et or.

Ecrire un programme qui effectue la division de deux entiers par des soustractions successives.

Solution : Voir le fichier Division.pas

program division;
uses crt;
var
  dividende, diviseur, quotient: integer;
begin
  clrscr;
  quotient := 0;
 
  writeln('Entrez le dividende');
  readln(dividende);
  writeln('Entrez le diviseur');
  readln(diviseur);
  while (dividende > diviseur) do
  begin
    dividende := dividende - diviseur;
    quotient := quotient + 1;
  end;
  writeln('Le quotient est : ', quotient);
  writeln('Le reste est : ', dividende);
 
  readln;
end.

Faire une variante de ce programme en utilisant la boucle repeat...until

Solution : Voir le fichier Division2.pas

program division2; 
uses crt; 
var dividende, diviseur, quotient: integer; 
begin 
  clrscr; quotient := 0; 
  writeln('Entrez le dividende'); 
  readln(dividende); 
  writeln('Entrez le diviseur'); 
  readln(diviseur); 
  repeat 
    dividende := dividende - diviseur; 
    quotient := quotient + 1; 
  until dividende < diviseur; 
  writeln('Le quotient est : ', quotient); 
  writeln('Le reste est : ', dividende); 
  readln; 
end.

Remarque :

• Comme on peut le constater, le programme ci-dessus produit des résultats erronés lorsqu'on entre une valeur du dividende inférieure à celle du diviseur. Ceci est dû au fait que les instructions des boucles repeat...until sont exécutées au moins une fois, ce qui n'est pas le cas des boucles while. Pour obtenir le même résultat, nous sommes alors obligés d'utiliser une instruction if pour tester le cas où le diviseur est supérieur au dividende.

Programmation d'un petit jeu de devinette

But : Le but du jeu est d'inviter l'utilisateur à deviner un nombre que l'ordinateur aurait "deviné" (en réalité, il s'agit d'un nombre aléatoire).

Principe : Dans un premier temps, le chiffre est choisi aléatoirement (il serait intéressant de lire en entrée la borne maximale du nombre aléatoire). Ensuite, l'utilisateur est amené à le deviner ; il sera aidé au cours de sa quête par des phrases du genre 'Plus petit' ou 'Plus grand' suivant que le nombre a deviné est respectivement soit plus petit, soit plus grand que le nombre entré...
Il faut préciser que l'utilisateur dispose d'un nombre fixe de tentative. Que ce soit à l'issue de ses nombres de tentatives ou qu'il devine le nombre caché (un message de félicitations est affiché le cas échéant), l'utilisateur est invité à taper n ou N s'il désire arrêter le jeu, ou alors une autre lettre pour continuer.

Préréquis : Consultez la fonction Random dans l'aide du compilateur.

Solution : Voir le fichier Devine.pas

program devine;
uses crt;
 
const
  NbrTentativeMax: integer = 10;
 
var
  nombre,
    valeur,
    ValMax,
    tentative: integer;
  car: char;
begin
  clrscr;
 
  randomize;
  tentative := 0;
  valeur := -1;
  car := 'o';
 
  repeat
    writeln('Entrez la borne maximale du nombre aléatoire');
    readln(ValMax);
  until ValMax > 2;
 
  writeln;
 
  repeat
    nombre := random(ValMax);
    while ((valeur <> nombre) and (tentative <= NbrTentativeMax)) do
    begin
      write('Entrez une valeur : ');
      readln(valeur);
      if (valeur > nombre) then
        writeln('Plus petit')
      else if (valeur < nombre) then
        writeln('Plus grand!');
      tentative := tentative + 1;
    end;
    if (valeur = nombre) then
      writeln('Vous avez gagné :)')
    else
      writeln('Vous avez perdu :(');
    writeln('Jouer encore ? n pour non, une autre touche pour oui');
    readln(car);
  until upcase(car) = 'N';
(*(car = 'n') or (car='N');*) 
 
end.

Commentaire :

• Comme vous avez dû le lire en consultant l'aide sur la fonction Random, il est nécessaire d'appeler la procédure Randomize d'abord. De plus, du fait que Random génère un nombre compris entre 0 et ValMax, on initialise valeur à -1 (en fait tout autre nombre négatif fait l'affaire), ainsi nous sommes sûrs qu'à l'entrée de la boucle while, la condition valeur<>nombre sera vraie.

Remarque :

• La condition de fin de boucle repeat, aurait pu aussi s'écrire : UpCase(Car)='N'. Nous n'avons eu besoin de l'unité Crt que pour utiliser la procédure ClrScr qui nettoie l'écran.