     Contents

Introduction à la Exercice 1 : première boucle while

Programmation
Impérative
TP : les boucles while Exercice 2 : Panique dans le noir
Exercice 3 : division euclidienne par
soustraction
Dans cette feuille, vous allez mettre en pratique la boucle while.
Exercice 4 : suite de Syracuse
 Search this book...
Exercice 5

Info 111 «Programmation Impérative»

Exercice 1 : première boucle while Bilan
Exercice 6 ♣

INFORMATIONS GÉNÉRALES
Exécutez les cellules suivantes :

Me contacter pour avoir de l’aide

#include <iostream>
Case départ using namespace std;

Exercices de programmation en ligne

(PL) int a,i;
Logiciels 

a = 35;
PROGRAMME HEBDOMADAIRE

Semaine 1: Introduction à 
i = 1;
l’informatique et premiers
while ( i < a ) {
programmes
cout << i << endl;
Semaine 2: Programmation  i = i*2;
}
impérative: premier aperçu

Semaine 3 : Mémoire, conditionnelles 

et boucles simples Modifiez la valeur de a ci-dessus pour obtenir :

Semaine 4: Fonctions
Semaine 5: Tableaux
Semaine 6 : Modèle de mémoire,
collections, consolidation

Exactement 1 affichage
 Exactement 0 affichage
 Exactement 4 affichages

Semaine 7 : tableaux à deux 

dimensions

Semaine 8 : fichiers 

Exercice 2 : Panique dans le noir
Semaine 9: débogage, tests, projet  Notre fourmi est perdue dans un labyrinthe plongé dans le noir. Elle panique! Avant chaque pas, elle
Semaine 10: modularité, compilation  tourne aléatoirement vers la gauche ou vers la droite. Va-t-elle trouver la sortie?
séparée

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

SOLUTIONS
À propos des solutions
Semaine 1: Introduction à
l’informatique et premiers
programmes
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.

std::string porteAleatoire() {
std::string s = u8"o o o o o o o\n";
s += u8"o → . . . . o\n";
int col = rand() % 5;
int ligne = rand() % 4;
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();
}
ouvre();
/// END SOLUTION

CHECK( a_gagne() );

Exercice 3 : division euclidienne par soustraction

Observez les cellules suivantes et donnez des valeurs à b et c avec b > c telles 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;
}

Test automatique (ne doit rien afficher) :

CHECK( b == 3 );

Modifiez la cellule ci-dessous pour que la variable k compte le nombre d’exécutions de la boucle;
Donnez 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

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

Vous noterez que lorsque le nombre d est pair, on le divise par 2. Lorsqu’il est impair, on le multiplie par
3 et on ajoute 1.

Modifiez la cellule pour que l’on répète cette action tant que le nombre d est supérieur à 1. On veut
afficher la valeur de d à chaque fois. Si votre code est correct, il doit afficher 16 8 4 2 1 (en partant
de d=5).

Exercice 5
Obervez la fonction suivante et essayez de comprendre ce qu’elle calcule en lisant le code et en
essayant plusieurs valeurs d’appel :

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

mystere(5)

Déterminez une valeur de n tel que la valeur renvoyée soit 6 :

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 ♣
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 × k avec k un entier. Par exemple 16 est
un carré parfait car 16 = 4 × 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
}

Essayez votre fonction sur les exemples suivants :

carreParfait(16) // doit renvoyer true

carreParfait(20) // doit renvoyer false

Vérifiez que votre fonction passe les tests automatiques suivants :

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

Précédent Suivant
 
TP : prélude : affichages TP : les boucles for

By Nicolas Thiéry et al.

© Copyright 2022 Licence libre Creative Commons CC-BY-SA.