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.