TP : boucles imbriquées#

Exercice :

Dans cet exercice, nous utiliserons les boucles imbriquées pour dessiner en laby. On veut dessiner ligne par ligne avec la fourmi et l’instruction seme(). Commencez par exécuter les cellules ci-dessous pour comprendre ce que fait l’instruction seme().

#include <iostream>
#include <cstdlib>
using namespace std;
#include <laby/global_fr.hpp>
#include "laby_check.hpp"
LABY_BAR(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ↑ . . . . . . . . . o\n"
u8"o o o o o o o o o o o o\n"
)

debut();
avance();
avance();
seme();
avance();
avance();
seme();
seme();
seme();
avance();
avance();
seme();
avance();
seme();
avance();
seme();

On vous donne la fonction avance_tant_que_tu_peux vue dans les premiers TPs.

/**Fait avancer la fourmi tant qu'elle a un espace vide devant elle.**/
void avance_tant_que_tu_peux() {
    while ( regarde() == Vide or regarde() == PetitCaillou ) {
        avance();
    }
}

Écrivez une fonction carre(int L) qui prend en paramètre un entier L, et qui fait dessiner à la fourmi un carré plein avec côtés de longueur L. Par exemple, pour \(L=5\), la fourmi dessinera :
```
*****
*****
*****
*****
*****
```

#include <laby/global_fr.hpp>
LABY_BAR(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ↑ . . . . . . . . . o\n"
u8"o o o o o o o o o o o o\n"
)

// Entrée : un entier L, correspondant à la longueur d'un côté de la trajectoire.
// Sortie : aucune, déplace la fourmi selon un carré de longueur L
void carre(int L){
    debut();
    /// BEGIN SOLUTION
    if (L > 0) {
        for (int i = 0; i < L; i++) {
            droite();
            for (int j = 0; j < L; j++) {
                seme();
                if (j != L-1){
                    avance();
                }
            }
            gauche();
            gauche();
            avance_tant_que_tu_peux();
            droite();
            if (i != L-1){
                avance();
            }
        }
    }
    /// END SOLUTION
}

carre(0) // La fourmi ne fait rien

carre(1) // La fourmi doit tourner et dessiner sur elle-même.

carre(5) // Dessin d'un carré plein avec côtés de longueur 5

CHECK( a_obtenu(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o o o o o o o o o o o o\n") )

Même question mais cette fois la fonction carre_vide(int L) affiche un carré vide. Pour l’exemple précédent, la fourmi dessinera :
```
 *****
 *   *
 *   *
 *   *
 *****
```

#include <laby/global_fr.hpp>
LABY_BAR(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ↑ . . . . . . . . . o\n"
u8"o o o o o o o o o o o o\n"
)

// Entrée : un entier L, correspondant à la longueur d'un côté de la trajectoire.
// Sortie : aucune, déplace la fourmi selon un carré de longueur L
void carre_vide(int L){
    debut();
    /// BEGIN SOLUTION
    if (L == 0)
        return;
    seme();
    for ( int i = 0; i < 4; i++ ) {
        for ( int j = 1; j < L; j++ ) {
            avance();
            seme();
        }
        droite();
    }
    /// END SOLUTION
}

carre_vide(0) // La fourmi ne fait rien

carre_vide(1) // La fourmi doit tourner et dessiner sur elle-même.

carre_vide(5) // Dessin d'un carré vide avec côtés de longueur 5

CHECK( a_obtenu(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o ŕ . . . ŕ . . . . . o\n"
u8"o ŕ . . . ŕ . . . . . o\n"
u8"o ŕ . . . ŕ . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o o o o o o o o o o o o\n") )

Écrire une fonction triangle_rect(int h) qui, pour un entier positif \(h\) donné, affiche le triangle rectangle plein avec côtés de longueur \(h\). Par exemple, pour \(h=5\), la fourmi dessinera :
```
    *
    **
    ***
    ****
    *****
```

#include <laby/global_fr.hpp>
LABY_BAR(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ↑ . . . . . . . . . o\n"
u8"o o o o o o o o o o o o\n"
)

void triangle_rect(int h) {
    debut();
    /// BEGIN SOLUTION
    for ( int i = 0 ; i < h ; i++ ){
        for (int j = 0 ; j < h - i ; j++){
            seme();
            avance();
        }
        gauche();
        gauche();
        avance_tant_que_tu_peux();
        gauche();
        avance();
        gauche();
        
    }
    /// END SOLUTION
}

triangle_rect(4)

triangle_rect(2)

triangle_rect(0)

triangle_rect(8)

CHECK( a_obtenu(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ŕ . . . . . . . . . o\n"
u8"o ŕ ŕ . . . . . . . . o\n"
u8"o ŕ ŕ ŕ . . . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ . . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ . . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ ŕ . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ ŕ ŕ . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ ŕ ŕ ŕ . . o\n"
u8"o o o o o o o o o o o o\n") )

♣ Écrire une fonction triangle_iso(int h) qui, pour un entier positif \(h\) donné, affiche le triangle isocèle pointe en haut, de hauteur \(h\) et de base \(2 h - 1\). Par exemple, pour \(h = 5\), la fourmi dessinera :
```
        *
       * *
      *   *
     *     *
    *********
```

#include <laby/global_fr.hpp>
LABY_BAR(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o ↑ . . . . . . . . . o\n"
u8"o o o o o o o o o o o o\n"
)

void triangle_iso(int h) {
    debut();
    /// BEGIN SOLUTION
    if ( h == 0 )
        return;
    seme();
    // dessine les deux côtés diagonaux
    for ( int i = 0; i <2; i++ ) {
        for ( int j = 1 ; j < h ; j++ ) {
            avance();
            droite();
            avance();
            gauche();
            seme();
        }
        droite();
    }
    // dessine la base
    droite();
    for ( int i = 0; i < 2*h; i++ ) {
        avance();
        seme();
    }
    /// END SOLUTION
}

triangle_iso(3)

triangle_iso(1)

triangle_iso(0)

triangle_iso(4)

CHECK( a_obtenu(
u8"o o o o o o o o o o o o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . . . . . . . . o\n"
u8"o . . . ŕ . . . . . . o\n"
u8"o . . ŕ . ŕ . . . . . o\n"
u8"o . ŕ . . . ŕ . . . . o\n"
u8"o ŕ ŕ ŕ ŕ ŕ ŕ ŕ . . . o\n"
u8"o o o o o o o o o o o o\n") )

Introduction à la Programmation Impérative

TP : boucles imbriquées

TP : boucles imbriquées#