Outils pour utilisateurs

Outils du site


darkpelouse:factorisation_tortue

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

darkpelouse:factorisation_tortue [2018/10/05 15:25] (Version actuelle)
195.221.62.1 créée
Ligne 1: Ligne 1:
 +# Factorisation de code avec la tortue
  
 +La tortue dont on parlera ici se déplace dans la fenêtre graphique en laissant une trace derrière elle. En lui donnant des instructions,​ il est possible de dessiner des merveilles.
 +
 +Pour plus d’informations,​ voir [cette page](http://​profgra.org/​lycee/​memento_des_tortues.html).
 +
 +## Étymologie
 +
 +En mathématiques,​ on dit qu’on *factorise* Z dans Z×Y + 2×Z quand on écrit :
 +
 +    Z×Y + 2×Z = Z×(Y+2)
 +
 +## Premier carré
 +
 +### Premier carré 1
 +
 +Explication des commandes :
 +
 +* `(RAZ)` remet à zéro l’espace de travail et replace la tortue au centre de la fenêtre graphique, tournée vers le haut ;
 +* `(AV 10)` signifie *avance* de 10 pixels ;
 +* `(TD 45)` signifie *tourne sur toi-même à droite avec un angle de 45 degrés*.
 +
 +Faites en sorte que le programme suivant dessine un carré de 100 pixels de côté.
 +
 +(MicroAlg "​carre"​ {"​processing":​ true})
 +(RAZ)
 +(AV 100)
 +(TD 90)
 +(AV 100)
 +(TD 90)
 +(AV 100)
 +(TD 90)
 +(AV 100)
 +(/MicroAlg)
 +
 +Maintenant que le programme dessine un carré de 100 pixels de côté, comment modifier le programme précédent pour dessiner un carré de 50 pixels de côté ?
 +
 +### Premier carré 2
 +
 +Pour nous simplifier la vie, nous allons utiliser une variable.
 +Elle va nous permettre d’éviter les répétitions.
 +
 +Faites en sorte que le programme suivant dessine un carré de 100 pixels de côté.
 +
 +L’idée est de ne faire apparaître le nombre 100 qu’une seule fois.
 +
 +(MicroAlg "​carre_var"​ {"​processing":​ true})
 +(RAZ)
 +(Declarer longueur De_type "​nombre"​)
 +(Affecter_a longueur 100)
 +(RAZ)
 +(AV longueur)
 +(TD 90)
 +(AV longueur)
 +(TD 90)
 +(AV longueur)
 +(TD 90)
 +(AV longueur)
 +
 +(/MicroAlg)
 +
 +Maintenant que le programme dessine un carré de 100 pixels de côté, comment modifier le programme précédent pour dessiner un carré de 50 pixels de côté ?
 +
 +Maintenant que la longueur du côté du carré est *factorisée*,​ la changer peut se faire en changeant **une seule** valeur. On a pu le faire grâce à la mise en place d’une variable.
 +
 +### Premier carré 3
 +
 +Pour nous simplifier encore plus la vie, nous allons utiliser la commande `Repeter`.
 +Elle va nous permettre d’éviter les répétitions.
 +
 +Faites en sorte que le programme suivant dessine un carré de 100 pixels de côté.
 +
 +(MicroAlg "​carre_repeter"​ {"​processing":​ true})
 +(RAZ)
 +(Repeter 4 Fois
 +    (AV 100)
 +    (TD 90)
 +)
 +(/MicroAlg)
 +
 +Comment modifier le programme précédent pour dessiner un carré de 50 pixels de côté ?
 +
 +Maintenant que la longueur du côté du carré est *factorisée*,​ la changer peut se faire en changeant **une seule** valeur. On a pu le faire grâce à la mise en place d’une boucle.
 +
 +## Plusieurs carré
 +
 +### Plusieurs carré 1
 +
 +Dessinez trois carrés.
 +
 +Vous pourriez avoir besoin des commandes `(LC)` et `(BC)`, qui permettent de *lever* et de *baisser* le crayon. Si la tortue a levé son crayon, elle ne laisse plus de trace derrière elle. Pour qu'​elle dessine à nouveau, il faut utiliser `(BC)`.
 +
 +(MicroAlg "​carres1"​ {"​processing":​ true})
 +(RAZ)
 +(Repeter 3 Fois
 +    (AV 100)
 +    (TD 90)
 +)
 +(AV 100)
 +(LC)
 +(AV 50)
 +(BC)
 +(Repeter 4 Fois
 +    (AV 100)
 +    (TD 90)
 +)
 +(AV 100)
 +(LC)
 +(AV 50)
 +(BC)
 +(Repeter 4 Fois
 +    (AV 100)
 +    (TD 90)
 +)
 +(/MicroAlg)
 +
 +### Plusieurs carré 2
 +
 +Grâce à `Definir`, on peut stocker le code du carré dans une commande. La vraie syntaxe, dans le cas où la commande ne prend pas de paramètre, est :
 +
 +    (!!! "Pour définir :")
 +    (Definir (Un_carre)
 +        "Un texte pour la documentation."​
 +        "Le nom de l’auteur."​
 +        (!!! "Le code..."​)
 +        (Retourner la_valeur_de_retour)
 +    )
 +    (!!! "Pour utiliser :")
 +    (Un_carre)
 +
 +Ici, on peut omettre la doc, l’auteur et le `Retourner`.
 +
 +(MicroAlg "​carres2"​ {"​processing":​ true})
 +(RAZ)
 +(Definir (Un_carre)
 +    (Repeter 3 Fois
 +        (AV 100)
 +        (TD 90)
 +    )
 +)
 +(Un_carre)
 +(Un_carre)
 +
 +    )
 +)
 +(Un_carre)
 +(Un_carre)
 +(/MicroAlg)
 +
 +Comment dessiner des carrés de différentes tailles sur le même dessin ?
 +
 +## Empilements
 +
 +### Empilements 1
 +
 +Dessiner :
 +
 +* un empilement de 3 carrés de taille 50,
 +* un empilement de 5 carrés de taille 20.
 +
 +Exemple de pile de carrés :
 +
 +    +-----+
 +    |     |
 +    |     |
 +    +-----+
 +    |     |
 +    |     |
 +    +-----+
 +    |     |
 +    |     |
 +    +-----+
 +
 +(MicroAlg "​empilements1"​ {"​processing":​ true})
 +(RAZ)
 +(Definir (Un_carre)
 +    (Repeter 3 Fois
 +        (AV 100)
 +        (TD 30)
 +    )
 +)
 +(/MicroAlg)
 +
 +### Empilements 2
 +
 +Créer une commande `Pile` qui empile les carrés, et utilisez-la pour coder les deux empilements précédents. Vous aurez sans doute besoin de modifier `Carre`.
 +
 +Nous aurons besoin de paramétrer la commande. La syntaxe est assez semblable :
 +
 +    (!!! "Pour définir :")
 +    (Definir (Un_carre longueur)
 +        "Une texte pour la documentation."​
 +        "Le nom de l’auteur."​
 +        (!!! "Le code..."​)
 +        (Retourner la_valeur_de_retour)
 +    )
 +    (!!! "Pour utiliser :")
 +    (Un_carre 100)
 +
 +(MicroAlg "​empilements2"​ {"​processing":​ true})
 +(RAZ)
 +(Definir (Un_carre)
 +    (Repeter 3 Fois
 +        (AV 100)
 +        (TD 30)
 +    )
 +)
 +(/MicroAlg)
 +
 +### Empilements 3
 +
 +Avant de lancer le programme suivant, exécutez-le vous-même sur une feuille de papier à la place de la tortue !  ​
 +Vérifiez ensuite si vous avez travaillé correctement.
 +
 +(MicroAlg "​empilements3"​ {"​processing":​ true})
 +(RAZ)
 +(Definir (Un_carre longueur)
 +    (Repeter 4 Fois
 +        (AV longueur)
 +        (TD 90)
 +    )
 +)
 +(Definir (Pile nbr longueur)
 +    (Repeter nbr Fois
 +        (Un_carre longueur)
 +        (AV longueur)
 +    )
 +)
 +(Declarer i long De_type "​nombre"​)
 +(Affecter_a i 1)
 +(Affecter_a long 60)
 +(Tant_que (<= i 6)
 + Faire
 +    (Pile i (/ long i))
 +    (LC)
 +    (TD)
 +    (AV (+ (/ long i) 10))
 +    (TD)
 +    (AV long)
 +    (TD 180)
 +    (BC)
 +    (Affecter_a i (+ i 1))
 +)
 +(/MicroAlg)
 +
 +## Conclusion
 +
 +Factoriser son code revient à le simplifier, le réduire, rassembler et centraliser des valeurs ou opérations qui se répètent
 +
 +Nous avons vu trois façons de factoriser du code :
 +
 +* avec une variable (utilisation de `Declarer`, `Affecter_a`) ;
 +* avec une boucle (ici avec `Repeter`, mais ça aurait pu être aussi avec `Tant_que...Faire` ou `Faire...Tant_que`) ;​
 +* avec la définition d’une commande (parfois appelées *procédures* ou *fonctions*,​ donc grâce à la commande `Definir`.
 +
 +Pour bien comprendre ce qu’il se passe lors de l’évaluation du code défini dans une commande, il faut comprendre les « environnements d’évaluation ».
 +
 +Traces d’une session :
 +
 +    (Declarer n De_type "​nombre"​)
 +    (Afficher n)
 +
 +    (Declarer n De_type "​nombre"​)
 +    (Affecter_a n 0)
 +    (Afficher n)
 +
 +    (Declarer n De_type "​nombre"​)
 +    (Affecter_a n 0)
 +    (Afficher n)
 +    (Affecter_a n 1)
 +    (Afficher n)
 +
 +    (Declarer n De_type "​nombre"​)
 +    (Affecter_a n 0)
 +    (Afficher n)
 +    (Affecter_a n 1)
 +    (Afficher n)
 +    (Definir (Affiche-STP!)
 +       ​(Afficher n)
 +    )
 +    (Affiche-STP!)
 +    (Affecter_a n 2)
 +    (Affiche-STP!)
 +
 +    (Declarer n De_type "​nombre"​)
 +    (Affecter_a n 0)
 +    (Afficher n)
 +    (Affecter_a n 1)
 +    (Afficher n)
 +    (Definir (Affiche-le-double-STP!)
 +       (!!! "​Attention,​ utilisation de variable globale"​)
 +       ​(Afficher (* 2 n))
 +    )
 +    (Affiche-le-double-STP!)
 +    (Affecter_a n 2)
 +    (Affiche-le-double-STP!)
 +
 +
 +    (Definir (Affiche-le-double-STP! n)
 +       (!!! "​Attention,​ utilisation de variable globale"​)
 +       ​(Afficher (* 2 n))
 +    )
 +    (Affiche-le-double-STP! 10)
 +    (Affiche-le-double-STP! 100)
 +
 +Diagrammes :​
 +
 +    +-----+--------+
 +    | nom | valeur | <-- environnement global
 +    +-----+--------+
 +    |  a  |    1   |
 +    |  b  |   ​17 ​  |
 +    | ... |  ...   |
 +    |     ​| ​       |
 +    +-----+--------+
 +
 +Cet environnement est remplacé par un autre quand on est « dans » une commande.
 +
 +    +-----+--------+
 +    | nom | valeur | <-- environnement d’exécution d’une commande
 +    +-----+--------+
 +    |  a  |    1   |
 +    |  b  |   ​10 ​  | <-- si b est passé en paramètre c’est cette valeur qui est utilisée, la valeur globale n’est pas vue
 +    |  x  |   ​-5 ​  |
 +    |  y  |   ​42 ​  |
 +    | ... |  ...   |
 +    |     ​| ​       |
 +    +-----+--------+
 +
 +Vocabulaire :​
 +
 +* paramètre formel (ou simplement *paramètre*,​ ou *variable*)
 +* paramètre effectif (ou *argument*)
 +
 +Sans paramètres:​
 +
 +    (Definir (Carré)
 +        (AV 40)
 +        (TD 90)
 +        ...
 +    )
 +    (Carré)
 +    (Carré)
 +
 +Avec paramètres :​
 +
 +    (Definir (Carré longueur) <-- paramètre formel
 +        (AV longueur)
 +        (TD 90)
 +        ...
 +    )
 +    (Carré 100) <-- paramètres effectifs
 +    (Carré 50)
darkpelouse/factorisation_tortue.txt · Dernière modification: 2018/10/05 15:25 par 195.221.62.1