Algorithmique - Séance 5 -Séance 4Séance 6

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.

    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.