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
x2
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=x2
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
x
et demander à
afficher chaque point
Mx ; f x
au fur et à mesure du calcul.
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
Prendre un compteur de 1 à 100
Prendre une variable "resultat" initialisée à 0
Ajouter le premier chiffre du compteur au
résultat et mémoriser ce résultat, le
compteur passe au chiffre suivant.
Tant que le compteur n'a pas terminé,
ajouter le chiffre du compteur au
"résultat" précédent.
Afficher le résultat.
Fin
Début
1 -> compteur
1 -> résultat
Tant que compteur<100
compteur +1 -> compteur
résultat + compteur -> résultat
afficher 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