Algorithme de tracé de courbe "Introduction de la boucle tant que" 2

Algorithme de tracé de courbe
"Introduction de la boucle tant que"
2 séances d'une heure
En introduction, je prévois 5 min pour vidéo projeter une calculatrice graphique (exemple Virtual
TI) traçant la fonction x 2 sur un intervalle convenable [-10 ; 10] par exemple.
L'idée est de leur demander comment la courbe est apparue: d'un coup? Point par point? Dans
quel sens? (de gauche à droite) Des points espacés? Rapprochés? Et donc à la fin, ils doivent être
capable de dire que les coordonnées d'un premier point sont calculés puis le point est affiché
ensuite on passe au prochain point etc... Mais on s'arrête quand? Et on démarre d'où?...
Ne pas hésiter à demander comment on trace une droite grace à son équation.
Exercice:
Soit la fonction f  x =x 2 définie sur [−3 ;3 ] . Écrire l'algorithme qui permet de créer la
courbe représentative de la fonction.
Réflexion:
La réflexion est moment privilégié pendant lequel on doit énumérer chaque étape dont on aura
besoin ou outil que l'on va utiliser:
- Il va falloir construire le tableau de valeur
- Combien de points? Si bcp, quel va être l'espace (le pas) entre chaque point? C'est le moment de
faire un schéma avec un espace d'une unité entre chaque point et discuter.
Affiche-t-on les points une fois le tableau de valeur créer? Ou au fur et à mesure du calcul de
chaque point? C'est l'occasion de sensibiliser les élèves sur la complexité en temps.
Le but de cet algorithme est de remplir le tableau de valeur pour plusieurs
afficher chaque point M  x ; f  x  au fur et à mesure du calcul.
x et demander à
Algorithme: La colonne de gauche est l'algorithme attendu en français sans pseudo langage. Les
élèves peuvent y réfléchir en groupe. La colonne de droite est l'algorithme écrit en pseudo langage
que le professeur pourra donner par la suite.
Début
1)
x prend la valeur -3
2)
Calculer f(x)
3)
Afficher le point M  x ; f  x 
4)
Ajouter 0.1 à x
5)
Recommencer les étapes 2) 3) et 4)
jusqu'à ce que x soit égal à 3.
Fin
Début
-3 -> x
tant que x<3
afficher M(x ; f(x))
x+ 0.1 -> x
Fin
Dans la colonne de droite, c'est l'occasion d'introduire la notion de "tant que". On notera le décalage
par rapport à la "marge" sous le "tant que", c'est une convention, cela signifie que tout ce qui est
décalé s'excécute dans le "tant que".
Exercice:
Comment calculer la somme de 1 à 100 (1+2+3+...98+99+100) avec la boucle tant que.
Réflexion:
Passer en revue la liste de 1 à 100 et additionner au fur et à mesure en sauvegardant les résultats
temporaires.
Si on essaie de calculer cette somme de tête (en mettant les élèves à contribution), on se rend
compte que l'on a besoin de quelqu'un qui compte et de quelqu'un qui calcule et mémorise chaque
résultat. Naturellement, on va pouvoir faire comprendre que pour l'algorithme c'est pareil, on
prendra un "compteur" et une variable "résultat".
Il faudra bien faire comprendre que l'action principale est portée par le compteur qui doit
absoluement passer en revue tous les nombres de 1 à 100 sans pour autant que les élèves écrivent
explicitement tous les nombres dans leur algorithme ce qui rendra l'outil algorithme inintéressant.
(cf l'algorithme précédent, on est parti de -3, on a trouvé le mécanisme pour passer aux nombres
suivants, sans les écrire!!!)
Le but de cet algorithme est de donner le résultat final au calcul demandé.
Algorithme:
Début
Début
Prendre un compteur de 1 à 100
1 -> compteur
Prendre une variable "resultat" initialisée à 0
1 -> résultat
Ajouter le premier chiffre du compteur au
Tant que compteur<100
résultat et mémoriser ce résultat, le
compteur +1 -> compteur
compteur passe au chiffre suivant.
résultat + compteur -> résultat
Tant que le compteur n'a pas terminé,
afficher résultat
ajouter le chiffre du compteur au
Fin
"résultat" précédent.
Afficher le résultat.
Fin
De manière générale, les élèves mettront compteur ≤100 ce qui peut être intéressant lorsque
vous déroulerez l'algorithme: on se rendra compte que la somme calculée sera 1+2+3+...
+99+100+101.
D'où l'intérêt du < et le besoin de vérifier.
Voici un version TI de l'algorithme que l'on peut proposer:
somme 
Prgm
1 i
1 resultat
While i100
i1 i
resultati i
EndWhile
Disp resultat
EndPrgm