# Exercice de tracés avec des caractères

L'objectif est d'écrire quelques procédures qui affichent des formes géométriques en utilisant le caractère dièse #. Par exemple, un pseudo-carré et un damier :

    #####
    #   #
    #   #
    #   #
    #####

      ##  ##  ##  ##
      ##  ##  ##  ##
    ##  ##  ##  ##  ##
    ##  ##  ##  ##  ##
      ##  ##  ##  ##
      ##  ##  ##  ##
    ##  ##  ##  ##  ##
    ##  ##  ##  ##  ##
      ##  ##  ##  ##
      ##  ##  ##  ##

Ces exercices vous permettront de gagner du temps pendant le projet des séances de TP suivantes.

Le seul acteur dont vous aurez besoin est l'acteur Gada.Text_IO

### Étapes à suivre

- Créez un nouveau dossier Exos-Algo
- Créez-y un fichier vide mission1.adb que vous complétez avec la structure d'usage (page 5 du livret du S1).
  Si vraiment vous n'y arrivez pas, exclamez-vous : O cursed spite that ever I was born to set it right! (Hamlet, Act I, Scene 5) puis copiez le fichier mission1.adb qui se situe sur commetud (comme au premier TP du premier semestre).
- Dans votre programme, qui s'appelle déjà `Mission1`, ajoutez une procédure `Tracer_Ligne` qui reçoit en argument un entier `Long` et qui trace une ligne de `Long` symboles dièses puis passe à la ligne. Par exemple, si Long vaut 3, la procédure affiche ###
  Pour tester, invoquer la procédure dans le corps du programme principal avec les arguments 3, 8, puis 20. Vous obtenez alors le résultat suivant :

      ###
      ########
      ####################

  Corps de la procédure : 4 lignes Ada.
- Ajoutez maintenant à votre programme une procédure `Tracer_Rectangle` qui reçoit deux arguments : `Largeur` et `Hauteur`, et qui trace (toujours avec des dièses) les contours d'un rectangle des dimensions indiquées (en nombre de dièses).
  Pour tester, invoquer la procédure dans le corps du programme principal avec les paires d'arguments (5,5), (4,6), puis (14,2). Vous obtenez alors le résultat suivant (utiliser des espaces " " pour décaler les dièses les uns des autres quand c'est nécessaire.) :

      #####
      #   #
      #   #
      #   #
      #####

      ####
      #  #
      #  #
      #  #
      #  #
      ####

      ##############
      ##############

  Corps de la procédure : une dizaine de lignes Ada.
- Ajoutez une procédure `Tracer_Quadrillage` qui reçoit aussi en argument une largeur et une hauteur.
  Pour tester si un nombre est pair :

  `X mod 2` vaut 0 lorsque X est pair et 1 lorsque X est impair.

  Invoquée avec la paire d'arguments (19, 11), votre procédure doit afficher ceci :

      ###################
      # # # # # # # # # #
      ###################
      # # # # # # # # # #
      ###################
      # # # # # # # # # #
      ###################
      # # # # # # # # # #
      ###################
      # # # # # # # # # #
      ###################

  Corps de la procédure : une dizaine de lignes Ada, un seul IF.
- Faites de même une procédure `Tracer_Damier` qui, invoquée avec les arguments (18,10) affiche ceci :

      # # # # # # # # #
       # # # # # # # # #
      # # # # # # # # #
       # # # # # # # # #
      # # # # # # # # #
       # # # # # # # # #
      # # # # # # # # #
       # # # # # # # # #
      # # # # # # # # #
        # # # # # # # # #

  Corps de la procédure : une dizaine de lignes Ada, un seul IF.
- Et enfin, écrivez une procédure `Tracer_Gros_Damier` qui, invoquée avec les arguments (18,10) affiche ceci :

        ##  ##  ##  ##
        ##  ##  ##  ##
      ##  ##  ##  ##  ##
      ##  ##  ##  ##  ##
        ##  ##  ##  ##
        ##  ##  ##  ##
      ##  ##  ##  ##  ##
      ##  ##  ##  ##  ##
        ##  ##  ##  ##
        ##  ##  ##  ##

  Corps de la procédure : une dizaine de lignes Ada, un seul IF.
  Si vous ne parvenez pas à afficher ce gros damier, inutile d'insister, passez à la suite.