TP : les boucles while

Contenu

TP : les boucles while#

Dans cette feuille, vous allez mettre en pratique la boucle while.

Exercice 1 : première boucle while

  • Exécutez les cellules suivantes :

#include <iostream>
using namespace std;

int a, i;

a = 35;

i = 1;
while ( i < a ) {
    cout << i << endl;
    i = i*2;
}

  • Modifiez la valeur de a ci-dessus pour obtenir :

  • Exactement 1 affichage

  • Exactement 0 affichage

  • Exactement 4 affichages

Exercice 2 : Panique dans le noir

Notre fourmi est perdue dans un labyrinthe plongé dans le noir. Elle panique! Avant chaque pas, elle tourne aléatoirement vers la gauche ou vers la droite. Va-t-elle trouver la sortie?

À vous de le découvrir en programmant ce comportement de la fourmi!

Pour simuler le noir, nous avons écrit une fonction qui place la porte de façon aléatoire. Exécutez les deux cellules suivantes. À chaque création du labyrinthe, la porte est placée dans un endroit différent. Le même programme doit toujours fonctionner !

Indications

  • Vous pouvez utiliser la condition regarde() != Sortie;

  • Pour tirer à pile ou face si la fourmi va tourner à gauche ou à droite, vous pouvez utiliser la fonction rand() qui renvoie un nombre entier aléatoire. Du coup, avec rand() % 2 vous obtenez un entier qui vaut aléatoirement 0 ou 1.

  • Rappel des commandes : debut(), avance(), droite(), gauche(), ouvre().

std::string porteAleatoire() {
    std::string s = u8"o o o o o o o\n";
    s += u8"o → . . . . o\n";
    int ligne = rand() % 4;
    int col = rand() % 5;
    for ( int i = 0; i < 4; i++ ) {
        s += "o ";
        for ( int j = 0; j < 5; j++ ) {
            if ( i == ligne and j == col ) {
                s += "x ";
            } else {
                s += ". ";
            }
        }
        s += "o\n";
    }
    s += u8"o o o o o o o\n";
    return s;
}

#include <laby/global_fr.hpp>
LABY_BAR(porteAleatoire())

debut();
/// BEGIN SOLUTION
while ( regarde() != Sortie ){
    if ( rand() % 2 == 0 ){
        gauche();
    } else {
        droite();
    }
    avance();
}
/// END SOLUTION
ouvre();

CHECK( a_gagne() );

Exercice 3 : division euclidienne par soustraction

  1. Observez les cellules suivantes et affectez des valeurs à \(b\) et \(c\) avec \(b > c\) de sorte que, à la fin de la boucle, on ait \(b=3\) :

int b,c;

/// BEGIN SOLUTION
b = 18;
c = 5;
/// END SOLUTION

while ( b >= c ) {
    b = b - c;
}

b

Test automatique (ne doit rien afficher) :

CHECK( b == 3 );

  1. Modifiez la cellule ci-dessous pour que la variable \(k\) compte le nombre d’exécutions de la boucle;

  2. Affectez des valeurs à \(b\) et \(c\) telles que l’on ait \(b=3\) et \(k=5\) à la fin de la boucle.

int k;

/// BEGIN SOLUTION
b = 23;
c = 4;
k = 0;
/// END SOLUTION
while ( b >= c ) {
    b = b - c;
    /// BEGIN SOLUTION
    k = k + 1;
    /// END SOLUTION
}

b     // doit afficher 3

k     // doit afficher 5

Tests automatiques :

CHECK( b == 3 );
CHECK( k == 5 );

Exercice 4 : suite de Syracuse

  1. Exécutez, sans les modifier, les deux cellules ci-dessous puis trois fois la troisième cellule :

#include <iostream>
using namespace std;
int d;

d = 5;

/// BEGIN SOLUTION
while (d > 1) {
/// END SOLUTION
    if ( d % 2 == 0) {
        d = d / 2;
    } else {
        d = 3 * d + 1;
    }
    cout << d << endl;
/// BEGIN SOLUTION
}
/// END SOLUTION

Exercice 5

  1. Observez la fonction suivante et essayez de comprendre ce qu’elle calcule en lisant le code et en l’appelant sur plusieurs valeurs d’entrée :

    BEGIN SOLUTION

    La fonction renvoie le plus petit entier \(k\) tel que \(k^2\) est supérieur ou égal à n.

    END SOLUTION

int mystere(int n) {
    int k = 0;
    while ( k*k < n ) {
        k = k + 1;
    }
    return k;
}

mystere(5)

int n;
/// BEGIN SOLUTION
n = 36;
/// END SOLUTION
mystere(n)

CHECK( mystere(n) == 6 )

Bilan#

Passez maintenant à la feuille d’exercices sur les boucles for. Vous pourrez, par la suite, aborder l’exercice plus avancé ci-dessous.

Exercice 6 ♣

  1. Complétez le code de la fonction suivante pour qu’elle détermine si \(n\) est un carré parfait. Dans ce cas, elle doit renvoyer true; sinon elle doit renvoyer false.

    Rappel: un carré parfait est un nombre qui peut s’écrire \(k\times k\) avec \(k\) un entier. Par exemple \(16\) est un carré parfait car \(16 = 4 \times 4\), mais \(20\) n’est pas un carré parfait.

bool carreParfait(int n) {
    /// BEGIN SOLUTION
    int k = 0;
    while ( k*k < n ) {
        k = k + 1;
    }
    if ( k*k == n ) {
        return true;
    } else {
        return false;
    }
    /// END SOLUTION
}

carreParfait(16)  // doit renvoyer true

carreParfait(20)  // doit renvoyer false

CHECK( carreParfait(0) );
CHECK( carreParfait(1) );
CHECK( not carreParfait(2) );
CHECK( not carreParfait(50) );
CHECK( carreParfait(100) );
CHECK( not carreParfait(250) );
Contenu