# Solutions du chapitre 4

# Table des matières

# Activité 1, page 44

Il suffit d'appeler la commande carre(cote) en fournissant les différentes valeurs en paramètre lors de l'appel.

# Activité 2, page 45

La commande hexagone vous est maintenant bien familière. Il suffit de reprendre le code de l'activité 1, page 32 en rajoutant un paramètre cote qui indique la longueur des côtés.

# Activité 3, page 45

Comme la commande doit être capable de dessiner n'importe quel polygone régulier, il faut qu'elle prenne le nombre de côtés en paramètre. Appelons ce paramètre nombre_cotes:

# Activité 4, page 46 (facultatif)

# Activité 5, page 48

Comme nous l'avons déjà à l'exercice-projet 6 du chapitre 4, page 41, il est très utile pour dessiner des animations de définir une seule commande pour dessiner une forme à animer qui prend ensuite un paramètre de couleur permettant d'utiliser cette même commande pour afficher l'objet et pour l'effacer ensuite en le redessinant dans la même couleur que le fond.

Par exemple, pour l'animation des planètes, on aurait pu définir une commande dessine_terre(rayon, couleur) de la manière suivante:

# Activité 6, page 48

# Dessine un escalier de huit marches ayant une hauteur de 16 et une longueur de 21

escalier(21, 16, 8)

# Activité 7, page 48

La tortue fait n'importe quoi. Elle ne dessine en tout cas pas un triangle rouge de côté 100. La raison est que Maria a inversé l'ordre des deux paramètres.

# Activité 8, page 48

Conseil de pro

Pour éviter ce genre d'erreurs, il faut éviter d'attribuer aux paramètres des noms qui n'ont pas de sens tels que s et f. Il vaut mieux utiliser des noms très significatifs tels que longueur_cote et couleur.

Le code suivant est bien plus lisible et compréhensible:

from gturtle import *

def triangle_couleur(longueur_cote, couleur):
    setPenColor(couleur)
    repeat 3:
        forward(longueur_cote)
        left(360 / 3)

makeTurtle()
triangle_couleur("red", 100)
1
2
3
4
5
6
7
8
9
10

# Activité 9, page 50

Attention

Pour le moment, il ne faut pas effectuer cette activité. Elle doit encore adaptée à la présentation faite sur le site. Cet exercice va probablement être supprimé.

# Activité 10, page 52

On commence par définir la commande carre(cote) pour dessiner un carré de côté cote. Cette commande est ensuite utilisée pour réaliser la commande rangee(cote, nb_carres). On définit également une commande

def va_a_droite(distance):
    right(90)
    forward(distance)
    left(90)
1
2
3
4

pour repositonner la tortue après chaque carré.

# Activité 11, page 52

Pour réaliser cet exercice, il s'agit de réutiliser la commande rangee(cote, nb_carres) définie dans l'activité précédente.

Remarques

  • Pour coder de manière plus propre, vous pouvez légèrement modifier la consigne pour que la commande grille prenne encore un paramètre additionnel cote. Il n'y a pas de raison de faire une commande qui ne puisse dessiner que des carrés de 10 de côté. Cela rend simplement la commande plus flexible.

  • Pour repositonner la tortue après le dessin d'une rangée, on définit une commande va_a_gauche(distance) qui ne fait rien d'autre que d'utiliser la commande va_a_droite(distance) déjà programmée dans l'activité précédente.

# Correction vidéo des activités 12 et 13

# Activité 12, page 53

Le programme n'est pas très difficile à réaliser. Ce qui est très important, c'est que la tortue se trouve dans la même position au début et à la fin du dessin de la flèche. Cela permet de mieux utiliser cette commande pour réaliser des dessins plus complexes par la suite.

Bonne pratique

  • Même si la donnée nomme la longueur des segments x, c'est plus pour faciliter le schéma. Lorsqu'on programme, on préférera néanmoins des noms significatifs et descriptifs tels que mesure_segment.

  • Veillez à bien laisser des espaces entre les opérateurs et les opérandes dans les opérations arithmétiques. On préfère donc écrire right(180 - angle) que right(180-angle).

Bien que la commande fleche soit de toute évidence appelée à être réutilisée dans l'exercice suivant et qu'il serait plus pratique que la tortue termine sa course à la pointe de la flèche, il vaut mieux tout de même la ramener à sa position originale pour ne pas déroger à la règle.

Le principe de conception est le suivant : lorsqu'on définit une commande, on ne sait en principe pas à l'avance à quoi elle va servir. Le but étant de définir une commande une fois pour la réutilisewqr un grand nombre de fois dans des contextes très différents, il faudrait éviter de la définir en fonction d'un usage particulier.

La fonction fleche pourrait par exemple servir à réaliser la figure ci-dessous:

Il est dans ce cas bien plus pratique que la tortue revienne à sa position de départ plutôt que de rester à la pointe de la flèche.

# Activité 13, page 53

Le plus important pour réaliser cet exercice est de réutiliser la commande de l'exercice précédent sans la modifier.

# Activité 14, page 53

Au lieu d'utiliser la technique décrite à la page 38 pour dessiner des carrés pleins, on utiliser ici une technique plus simple qui demande moins de bricolage. La fonction carre_couleur(cote, couleur) est ainsi plus naturelle, plus facilement compréhensible et plus facilement utilisable.

# Activité 15, page 54

La commande va_a_droite() doit simplement décaler la tortue d’un pas à droite, afin de pouvoir dessiner le carré suivant sans créer de chevauchement entre les deux carrés.

def va_a_droite(longueur):
    penUp()
    right(90)
    forward(longueur)
    left(90)
    penDown()
1
2
3
4
5
6

# Activité 16, page 54

# Activité 17, page 54

La commande rangee_carres() est appelé avec les paramètres

rangee_carres(65, 3, "yello", "purple")
1

Cela signifie qu'au sein du corps de la commande rangee_carres(), le tableau de valeur des paramètres pour l'appel de la commande rangee_carres(65, 3, "yello", "purple") est donc

Name Wert
cote 65
n 3

La commande va_a_gauche() va donc être appelée à la ligne 14 avec l'expression cote * 2 * n qui est évaluée à 390. Le paramètre longueur, pour cet appel de commande, a donc la valeur 390.

# Activité 18, page 55

Dans cet exercice, on rassemble tous les différents composants logiciels (briques de base) développés dans les exercices 14 à 16 et les exemples 11A et 11B. La réalisation du programme pour dessiner un échiquier montre bien la stratégie à utiliser pour développer un projet complexe à l'aide de la conception modulaire.

Voici le code complet pour résoudre l'exercice 18.

# Activité 19, page 55

Il suffit d'appeler la commande echiquier() comme suit:

echiquier(25, 4, 6, "brown", "yellow")
1

# Exercice 1, page 57

Pour réaliser cet exercice, il faut utiliser la conception modulaire. Il y a plusieurs stratégies différentes se faire une idée de la manière de décomposer le problème.

Stratégie de résolution de problème

On peut utiliser une approche "top-down" dans laquelle on commence par développer la commande double_escalier(nombres_marches) ou une approche "bottom-up" où l'on commence par les plus petites briques (la commande marche()). L'une comme l'autre fonctionne très bien mais il se peut que l'une d'elle vous convienne mieux.

On peut même d'une certaine manière utiliser ces deux approches. Pour conceptualiser le problème, on peut par exemple utiliser la méthode "top-down". Une fois qu'on a effectué la décomposition du problème en allant du "grand" vers le "petit", on peut utiliser l'approche inverse lors de l'implémentation de la stratégie (lorsqu'on écrit le code).

# Conceptualisation par l'approche top-down

L'approche "top-down" consiste à partir de la vision d'ensemble (le problème dans son entier) et le décomposer petit-à-petit jusqu'à parvenir aux briques de base.

  1. On voit que pour dessiner l'escalier dans son entier, il faut définir une commande double_escalier(nombre_marches) permettant de dessiner l'escalier dans son ensemble. Cette commande ressemblera à quelque chose comme

    def double_escalier(nombre_marches):
    escalier()
    avancer()
    escalier()
    1
    2
    3
    4

  2. On voit que pour dessiner le double escalier, il faut d'abord savoir dessiner un escalier simple. On définira donc à cet effet une commande escalier(). On sait d'avance qu'il faut pouvoir faire varier le nombre de marches des escaliers. On va donc définir la commande avec un paramètre nombre_marches. Mais tant qu'on y est, pourquoi ne pas aussi avoir un paramètre hauteur pour définir la hauteur de l'escalier et largeur pour définir sa largeur? On obtient alors une commande escalier de la forme

    def escalier(nombre_marches, hauteur, largeur):
    repeat nombre_marches:
        marche(hauteur / nombre_marches, largeur / nombre_marches)
    1
    2
    3

  3. Pour dessiner l'escalier, il faut définir une commande marche de la manière suivante :

    def marche(hauteur, largeur):
    forward(hauteur)
    right(90)
    forward(largeur)
    left(90)
    1
    2
    3
    4
    5

# Approche "bottom-up" pour l'implémentation

Maintenant que l'approche top-down nous a permis de déterminer les commandes à définir, on peut utiliser l'approche "bottom-up" pour partir de la plus petite brique de base (la commande escalier) pour aller vers des briques toujours plus grosses.

Conseil

On veillera à tester chaque commande de manière isolée après l'avoir définie.

# Définir et tester la commande escalier(hauteur, largeur)

On définit et on teste la commande escalier en vérifiant qu'elle fonctionne pour plusieurs valeurs différentes des paramètres hauteur et largeur.

On voit que la commande marche() fonctionne correctement. On peut ensuite définir la commande escalier:

Maintenant que l'on sait que la commande escalier fonctionne correctement à cause du test (ligne orange), on peut dessiner l'escalier dans son entier avec la commande double_escalier. Pour que le double escalier fasse bien 500 de large et 200 de haut, il faut dessiner deux escaliers de largeur frac5002=250frac{500}{2} = 250 et de hauteur identique 200200:

Astuce

Lorsqu'on dessine le premier escalier qui monte, la tortue commence par monter à la verticale et dessine ainsi la hauteur d'une marche. En revanche, lorsqu'elle dessine le deuxième escalier en descendant, elle dessine d'abord la largeur d'une marche. Pour ne pas avoir à définir une nouvelle commande pour dessiner le deuxième escalier en descendant, il suffit de se tourner

  1. Tourner la tortue de 90°90° à droite
  2. Dessiner l'escalier descendant en faisant comme si les largeur étaient des hauteur et vis-versa.

Pour dessiner le deuxième escalier, on inverse donc l'ordre des paramètres : on passe d'abord la largeur et ensuite la hauteur:

escalier(4, 500 / 2, 200)

À ce stade, le problème est résolu. On aurait toutefois pu rendre la commande double_escalier un peu plus flexible et lui donner en paramètre la hauteur et la largeur du double escalier:

def double_escalier(nombre_marches, hauteur_tot, largeur_tot):
    escalier(nombre_marches, hauteur_tot, largeur_tot / 2)
    right(90)
    escalier(nombre_marches, largeur_tot / 2, hauteur_tot)
double_escalier(4, 200, 500)
1
2
3
4
5

# Exercice 2, page 57

On peut facilement identifier un motif qui se répète dans l'illustration : la pyramide. Il faut donc définir une commande nommée par exemple pyramide pour dessiner ce motif. De plus, comme la taille des pyramides doit pouvoir être déterminée lors de l'appel de la commande, il qu'elle prenne un paramètre cote ou longueur.

# Exercice 3, page 57

Il suffit de se rappeler qu'un carré n'est rien d'autre qu'un 4-gone régulier, à savoir un polygone régulier à 4 côtés.

# Projet 4, page 57

WARNING

Le projet 4 est plus conséquent que les autres exercices et permet plus de liberté. Il est intéressant de réaliser ce genre d'exercices par groupes de deux ou trois personnes. Il faut alors veiller à ce que chacun puisse contribuer à la réalisation du programme.

Voici un exemple de solutions. Il est bien entendu possible de réaliser des fleurs encore plus jolies. Ce projet étant plus conséquent et libre, le code n'est pas fourni dans ce corrigé. Le code est plutôt présenté sous forme de vidéo qui montre comment réfléchir pour décomposer le problème

# Projet 5, page 54

Le corrigé de ce projet n'est pas (encore) disponible. Laissez libre cours à votre imagination pour la réalisation de ce projet.

Dernière modification: 4/28/2020, 9:13:58 AM