Objectifs

  • Parcourir les tableaux et matrices.
  • Exploiter l'information d'une structure imbriquée.

Prérequis

Mission 1

La transformation d'une image en Ascii-Art (voir image ci-contre) nécessite de manipuler des caractères (des lettres), ceux qui servent à reconstituer l'image. Dans ce premier TP, nous nous concentrons donc sur la forme graphique des caractères, fournie sous forme de matrice.

Descente dans la table

 
                                  ```````                                  
                         ```'''`````  ``````'''`,,`                        
                    ```'`                         ``'``                    
                 ,`'                                   ''``                
              ,'`                                         `^,              
           `,'                                               `'`           
        ,,!~..`````````````````````,`'`,,``````````````````'''.'!,,        
        |'~ws\~`                `/kx^^''~!,                `,~x?J~~`       
      `-'  `~*.-,-'``,`         *XO**^*\k);`         `,,--^./r!~' ^-`      
     _' '      `^',`  `^,```    *5Q[jx/]%*/     `,,-'` ``,--`     -`'`     
    _'  ',,,`      `''',._``,-'^-%%{*/~7Y)--_^^'```,,`'''      ```_` ^`    
   `^   xcanr_~~,``'''^-''^-~~'``^^'^~,'^~``!_.~'~-,-''''''--:!x)=v`  ^`   
   ^    ''`'''^^''``-,---'',,.~~,    `    `.x,,,,,^',``',,'--+^~~'^`   ^   
  ~`    '                      =0r^,--~'+-!x`                     -`   `.  
  '     '                       '    `    '^                      -`    '  
 `^     '                       -`       `'                       -`    ^` 
 '`     '                       '' ` _ ```'                       _`    `, 
 '`     '                       x'   ^   `~                       ^`    `, 
 `,     '                      `'       ` !`                      -`    `' 
  '     '                     `~`  ``,'_  ''                      -`    _` 
  '     '                    ````` `''~`  ,`,                     ^`    '  
  `.    '                   `` '  `'`^^,  '  ,                    -`   ``  
   ^`   '                   '  `,`` `' '` '  _`                   -`  `'   
    ^   '                  ,' `,^   ~'  `''  `'                   -`  ^    
     ^  '                `-```-`'   .'`  ,-,` '`                  -``-     
      -`'              `-` `-`  .` `-^' `' ',`'!`                 -'-      
       ''             .'  `'    _``.`'`'.`  ^`  ^,                ~^       
       `^`           `^  `'    ,` `',  `^    ' ` `.             `-^`       
       `'  '`        .  ,`     '   '.   ,     ',  ,`          `'` -`       
       `'    ``     `'`'       '`  .'`  ,      `,` -`       `'`   _`       
       `'       ``^--`^         '  ^ ~  ,        '. '-,_.,'`      -`       
       `'         `^-~'         `'`-`^  !         ^_`.,^`         ^`       
       `'             ``         ,-`^`'`'''`    ```'`             ,`       
       `-'''''''''''''''''''---+*Y!+~=^''''--~-'''````````````````-`      
  • Créez un dossier pour tous vos prochains TPs d'algo, nommez-le algo2 (sans espace !). Copiez-y le fichier mission1.adb que vous trouvez sur commetud.
  • Écrire un programme Mission1 qui demande poliment à l'utilisateur de taper un entier (n) une fois, et qui affiche ensuite la valeur de n deux fois. Testez.
  • Star Complétez votre programme : affichez ensuite le caractère contenu dans la n-ème case de la table, avec GAda.Text_IO.Put(Aff : character).
    • Pour tester : le caractère numéro 32 est un 'C'.
    • Il vous faut bien comprendre l'acteur Caracteres. Pour cela, réfléchissez à deux, et lisez ces commentaires :
    • L'information que l'on cherche se trouve dans la variable Table. C'est un tableau (array). Voyez votre poly pour comprendre ce qu'est un tableau.
    • Chaque case de ce tableau contient un type article T_Paire (chaque case est différente).
    • On vous demande d'afficher le caractère contenu dans cet article.
    • En résumé, il faut donc trouver comment accéder à la N-ème case de la Table, et obtenir le caractère contenu dans le type article présent dans cette case.

Parcours de matrice

  • StarAjoutez un sous-programme : la procédure Afficher_TrameProcedure Afficher_TramePour afficher la trame, on parcourt la matrice ligne par ligne et colonne par colonne. Si la case contient un pixel allumé, on affiche un # (avec GAda.Text_IO.Put), si le pixel est éteint, un espace.
    Pour détecter si le pixel est éteint ou allumé, utiliser un bloc CASE.
  • Pensez à ajouter une procédure de test : Tester_Afficher_Trame qui affiche la trame de 3 ou 4 caractères de votre choix. Procedure Tester_Afficher_Trame
  • Écrivez une procédure Afficher_Mot qui reçoit en argument une chaîne (String) et qui affiche verticalement les trames des caractères de cette chaîne. Si vous avez besoin de créer une fonction auxiliaire, c'est normal.Procedure Afficher_Mot
    Le type String est un tableau de Character :
    type String is array(Integer range <>) of Character
    Le numéro de la première case n'est pas forcément 1, il s'obtient avec la notation 'First.
  • Testez en affichant votre nom.
  • Défi (facultatif)Afficher maintenant votre nom horizontalement. N'oubliez pas d'écrire d'abord l'algorigramme sur papier.

Acteurs utilisés

Bilan

  • Une matrice dans un type article dans un tableau ne vous fait pas peur.
  • ..mais saurez-vous manipuler un type article dans une matrice ? (cf Mission 2)