ÔĽŅ

1.6 - Boucle for

Nous avons vu comment faire quelques boucles avec l'instruction 'loop'.
Il serait interessant et util de connaitre dans quel tour nous sommes, n'est-ce pas ?
C'est ce que nous avions fait dans le tutoriel sur le conditionnel.
'For' est une instruction qui va nous aider à faire cela.

synopsis

  1. prérequis
  2. notions de base
  3. for
  4. étape
  5. compte à rebours
  6. à toi de jouer
  7. sommaire

  8. << retour aux tu(r)toriaux

prérequis

Avant de lire ce tutoriel, il est important d'avoir lu : 1.1 - Qu'est ce qu'un programme ?1.3 - Boucles loops1.4 - Variables

notions de base

Nous avons vu ce qu'était une boucle
Il est possible, mais peu intuitif, de connaitre le numéro de décompte lorsque le programme est dans la boucle.

 
boucle loop: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

set i = 0; // initialisation
loop (4) { // boucle tant que le compteur est < 4
  algo.text ("le tour actuel est " .. i);
  i++; // equivaut √† i = i + 1
}
 


Note sur le code précédent : la boucle fonctionne 4 fois.
Donc i est initialisé à 0 et est incrémenté 4 fois donc : 0, 1, 2, 3
Pas 4, parce que 0 est considéré comme une itération.
Ce comportement n'est pas intuitif, mais il est du au fait que l'initialisation soit à 0 et que l'incrémentation s'effectue à la fin de la boucle comme ici.
En fait si j'ai donné cet exemple, c'est que la boucle 'for' fonctionne de la même manière.


L'instruction 'for' est conçu pour faire cela sur une seule ligne.
Elle permet de déclarer la variable, de l'initialiser et de l'incrémenter à chaque tour.
Le code suivant peu-t-être traduit de la sorte :

 
for sur une ligne: 
  • 1
  • 2
  • 3
  • 4
  • 5

for (set i = 0 /* initialisation */; i < 4 /* condition */; i = i + 1 /* incrémentation */)
  algo.text ("le tour actuel est " .. i);
}
 


Notons que i = i + 1; peu-t-être écrit i++;

for

for

'for' est une instruction complexe mais utile.
Elle sert à répéter plusieurs fois une instruction (ou, nous l'avons vu, un bloque).
'for' est construit comme suivant :
for ([initialisation de la variable]; [condition de sortie]; [itération]) [instruction(s)]
La séquence du programme est :

  • 1 D'abord la variable est initialis√©e.
  • 2 La condition est v√©rifi√©e, si ok, alors on continue, sinon exit.
  • 3 La variable est it√©r√©e.
  • 4 Allez √† 2.
 
encore un carr√©: 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
// encore un carré
for (set i = 0; i < 4; i = i + 1) {
  algo.go (100);
  algo.turnRight (90);
}
// fin de la boucle
algo.hide ();
Traduction:
Initialisation, création de la variable i et met i à 0

Vérifie si i est inférieur à 4, oui il l'est 0 ? Ok continue
Avance de 100
Tourne √† droite de 90¬į
Itère, i = i + 1 donc i = 0 + 1 => i = 1

Vérifie si i est inférieur à 4, oui il l'est 1 ? Ok continue
Avance de 100
Tourne √† droite de 90¬į
Itère, i = i + 1 donc i = 1 + 1 => i = 2

Vérifie si i est inférieur à 4, oui il l'est 2 ? Ok continue
Avance de 100
Tourne √† droite de 90¬į
Itère, i = i + 1 donc i = 2 + 1 => i = 3

Vérifie si i est inférieur à 4, oui il l'est 3 ? Ok continue
Avance de 100
Tourne √† droite de 90¬į
Itère, i = i + 1 donc i = 3 + 1 => i = 4

Vérifie si i est inférieur à 4, non! Il est égal à 4 ? Exit et continue après le bloque
Cache la tortue d'algo

étape

Avec la boucle 'for', il devient possible de compter avec d'autres pas que 1.
Par exemple, pour compter de 2 en 2.
Pour faire cela, deux choses sont nécessaires :

  • Changer le pas (l'incr√©ment) de l'instruction 'for'
  • Faire tr√®s attention √† ce que ce saut ne d√©passe pas la condition. C'est pour √ßa qu'on pr√©f√®re v√©rifier que le compteur soit < ou > plut√īt que == (√©gale)

 
de 2 en 2: 
  • 1
  • 2
  • 3
  • 4
// compte de 2 en 2
for (set i = 0; i <= 8; i = i + 2) {
  text.output ("De 0 √† 8 inclus de 2 en 2 : " .. i);
}

La condition i < garantie que si i deviens supérieur à 8 la boucle va tout de même sortir.
i = i + 2 va incrémenter i par 2 à chaque tour.
Note que la condition est i <= 8, ce qui inclus 8 : 0, 2, 4, 6, 8

compte à rebours

Il est également possible d'utiliser l'instruction 'for' pour faire un compte à rebours.
Pour faire cela, deux choses sont nécessaires :

  • Changer le pas (l'incr√©ment) par une valeur n√©gative
  • Inverser le nombre de d√©part et celui de la condition d'arriv√© pour allez du plus grand au plus petit

 
compte √† rebours: 
  • 1
  • 2
  • 3
  • 4
// compte à rebour
for (set i = 8; i >= 0; i = i - 1) {
  text.output ("De 8 √† 0 de pas -1 : " .. i);
}

Le programme va allez depuis 8 à 0 à rebours Il est initialisé avec 8 et la condition vérifie qu'il soit plus grand ou égale à 0 Execute le en mode pas à pas pour voir ce qu'il ce passe (c'est vrai pour tous les exemples).
Note : L'itération i = i - 1 peu-t-être écrit i--

à toi de jouer

Une autre façon d'écrire un pentagone

Crée un pentagone

Un pentagone est constitué de 5 lignes

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
// boucle 5 fois
for (set i=0; i<5; i++) {
  algo.go (100);
  algo.turnRight (360 / 5);
  // las rotation totale divis√© par le nombre de ligne
}
 

Polygone

Crée polygone

Un polygone est constitué d'un nombre quelconque de ligne

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
// boucle x fois
set nbEdge = 8; // utilise une variable
for (set i=0; i<nbEdge; i++) {
  // boucle sur le nombre de ligne
  algo.go (80);
  algo.turnRight (360 / nbEdge);
  // la rotation compl√®te divis√© par le nombre de ligne
}
 

Polygone définit par l'utilisateur

Dessine un polygone dont le nombre de ligne et la taille sont déterminés par l'utilisateur de ton programme.

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
// demande à l'utilisateur
set nbEdge = text.inputNumber("Combien de ligne(s) ?");
set size = text.inputNumber("Quel est la taille des lignes ?");
for (set i=0; i<nbEdge; i++) {
  // boucle sur le nombre de ligne
  algo.go (size);
  algo.turnRight (360 / nbEdge);
  // la rotation compl√®te divis√© par le nombre de ligne
}
 

Boucles imbriquées

Dessine la figure suivante

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
// constantes
set nbGeom = 10;
set nbEdge = 20;
set size = 25;

// la première boucle de notre géométrie
for (set g=0; g<nbGeom; g++) {
  // la seconde
  for (set i=0; i<nbEdge; i++) {
    algo.go (size);
    algo.turnRight (360 / nbEdge);
  }
  algo.turnRight (360 / nbGeom);
}
 

Joue avec les paramètres pour obtenir des géométrie amusantes

Variation sur les étoiles à base de ligne

Dessine une étoile à base de ligne en augmentant la taille des lignes

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
// constantes
set nbBranche = 20;
set factor = 10;

algo.hide();

for (set i = 0; i < nbBranche; i++) {
  // dessine une branche
  algo.go (factor * i); // utilisation du compteur de tour
  // retourne √† la position et la rotation initiale
  algo.turnLeft (180);
  algo.go (factor * i);
  algo.turnLeft (180);
 
  // tourne pour la prochaine branche
  algo.turnLeft (360 / nbBranche);

}

Labyrinthe

Avec le changement de taille des branches de l'étoile, nous avons vu l'importance de la variable de compteur.
Essaie de dessine la spirale √† 4 c√īt√©s comme suivant :

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
// labyrinthe
set size = 0; // initialisation de la variable
// boucle de la spirale
for (set i=0; i<45; i++) {
  size = size + 10;
  algo.go (size);
  algo.turnLeft (90);
}

Spirale triangulaire

Quelles sont les modifications dans le code précédent pour obtenir la figure suivante :

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
// spirale
for (set i=0; i<450; i=i+10) {
  algo.go (i);
  algo.turnLeft (121);
}

Spirale

Joue avec les valeurs pour obtenir la figure suivante :

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
// spirale
for (set i=0; i<45; i=i+0.1) {
  algo.go (i);
  algo.turnLeft (10);
}

Etoile

Dessine une étoile dont le nombre de branche est choisi par l'utilisateur

 
Solution : 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
// demande à l'utilisateur
set nbBranche = text.inputNumber("Combien de branches ?");

algo.hide ();

for (set i=0; i<nbBranche; i++) {
  algo.turnLeft (60);
  algo.go (70);
  algo.turnRight (120);
  algo.go (70);
  algo.turnLeft (60);

  algo.turnRight (360 / nbBranche);
}
 
ÔĽŅ

sommaire

connaissances

Dans ce tutoriel, vous avez appris :

  • qu'est ce que la boucle for ?
  • comment l'utiliser ?
  • comment l'utiliser pour faire un compte √† rebour ?
  • what are the loop instructions and structure ?
  • comment l'utiliser pour faire des dessins encore plus beau ?

fonctions utilisées :

FonctionDéscription