7ExercicesDeBouclesImbriquees CORRIGE

QUESTION 1)
Soit le code suivant :
string s = ″Programmer me rend fou!″;

int tailleDeLaChaine = s.Length;
int a = 3;
int b, c, indiceDansLaChaine;
for(int i = 0; i < a; i++){
b = 4 + i;
c = b + 1 + i;
do{
indiceDansLaChaine = 0 + i;
while (indiceDansLaChaine < tailleDeLaChaine)
{
Console.Write(s[indiceDansLaChaine]);
indiceDansLaChaine++;
}
b++;
Console.WriteLine(b);
} while (b<c);
}
CE À QUOI VOUS POUVEZ VOUS ATTENDRE :

L’affichage aura un total de six lignes.
La phrase spécifiée dans le code sera toujours présente, par contre parfois avec un ou des
caractères manquants. Il y aura toujours un nombre à la fin de chacune des lignes, et il y a
une certaine séquence qui s’applique à ces nombres.
SOLUTION :
Voici la trace complète de ce code :

a=3
Premier tour de boucle du for (i = 0):
b = 4 + 0 = 4;
c=b+1+i=4+1+0=5
Premier tour de boucle du « do while » :
indiceDansLaChaine = 0 + i = 0 + 1 = 1
Analyse du while : tant que « indiceDansLaChaine » est inférieur à la taille de la
chaîne, le code affiche le caractère à la position « indiceDeLaChaine » et affiche
ainsi toute la chaîne (avec bien sûr incrémentation de l’indice à chaque tour de
boucle).
Après le while : b est incrémenté (passe de 4 à 5), est affiché à l’écran et il y a un
saut de ligne en raison de la méthode appelée. Ce qui est affiché à la console ici
est donc « Programmer me rend fou!5 ».
Condition du do while : 5 < 5  faux. Le « do while » s’arrête.
Deuxième tour de boucle du for (i = 1):
b = 4 + 1 = 5;
c=b+1+i=5+1+1=7
Analyse du while : on affiche toute la chaîne mais en commençant cette fois à
l’indice 1, et non 0.
est donc « rogrammer me rend fou!6 ».
Condition du do while : 6 < 7  vrai. Le « do while » continue.
Deuxième tour de boucle du « do while » :

indiceDansLaChaine : reste inchangé à 0 + i = 0 + 1 = 1
Analyse du while : encore une fois, on affiche toute la chaîne mais en
commençant toujours à l’indice 1, et non 0.
est donc « rogrammer me rend fou!7 ».
Troisième tour de boucle du for (i = 2):

b = 4 + 2 = 6;
c=b+1+i=6+1+2=9
Analyse du while : on affiche toujours la chaîne mais en commençant cette fois à
l’indice 2.
est donc « ogrammer me rend fou!7 ».

indiceDansLaChaine : reste inchangé à 0 + i = 0 + 2 = 2
commençant toujours à l’indice 2.
Troisième tour de boucle du « do while » :

indiceDansLaChaine : demere toujours inchangé à 0 + 2 = 0 + 2 = 2
commençant encore une fois à l’indice 2.
AFFICHAGE FINAL:
Programmer me rend fou!5

rogrammer me rend fou!6
rogrammer me rend fou!7
ogrammer me rend fou!7
QUESTION 2)
int nombre = 0;
for (int i = 0; i < 3; i++){

for (int j = 0; j < i + 1; j++){
do {
nombre++;
while (nombre % 3 != 0) {
nombre++;
}
} while (nombre % 5 != 0)
if (nombre % 2 = = 0)
Console.Write(j + 1);
else
Console.Write((char)(97 + j));
}//Fin du 2ième for
Console.WriteLine();
}//Fin du premier for

Une réponse qui tient sur trois lignes d’affichage.
Les deux dernières lignes ont le même début.
Le nombre total de caractères est le double du nombre de lignes.
SOLUTION :
Le for de « premier niveau » roulera donc 3 fois, les valeurs de i étant alors 0,1,2.
LE TOUR DE BOUCLE OÙ i = 0.
Le for de « deuxième niveau » roule alors une seule fois, le compteur « j » valant 0.
Dans le « do while », la variable « nombre » est incrémentée, passant initialement de 0 à

1. Ensuite, il y a un « while » qui roule tant que « nombre » n’est PAS un multiple de 3.
Lorsque «nombre» vaudra donc 3, on teste alors le while du « do while ». Celui-ci nous
fait recommencer le do while tant que «nombre» n’est pas un multiple de 5.
Les exécutions combinées du « do while » et du « while » font donc en sorte qu’on ne
sortira de cette structure de contrôle conjointe que lorsque « nombre » sera un multiple de
15, donc simultanément de 3 et de 5.
Lors de ce premier tour de boucle du for de 1ier niveau et l’unique tour de boucle du for
de 2ième niveau, « nombre » vaudra 15 quand on sortira du « do while ». On teste alors si
le nombre est pair ou pas. Avec 15, ça ne l’est pas, donc on exécute
«Console.Write((char)(97 + j));». Comme j vaut 0, ceci affiche le caractère dont le code
ASCII est 97 (il y a conversion explicite). Ceci affiche donc ‘a’.
Puis, saut de ligne.
Le for de 2ième niveau roule alors deux fois, j valant tour à tour 0 et 1.
Quand j vaut 0, la variable « nombre » sera incrémentée jusqu’à valoir 30 (rappel : on ne

sort du «do while» et du « while » combinés que lorsque « nombre » est un multiple de
15).
30 étant pair, on affiche « j + 1 » à la console, donc 1.
Tout de suite après, j vaut 1. La valeur de « nombre » se rendra à 45, qui est impair. On
affiche donc le caractère dont le code ASCII est 97 + 1 – donc 98 -, soit ‘b’.
L’affichage combiné de ces deux éléments est donc 1b.
Le for de 2ième niveau roule alors trois fois, j valant tour à tour 0, 1 et 2.
Quand j vaut 0, la variable « nombre » sera incrémentée jusqu’à valoir 60.
60 étant pair, on affiche « j + 1 » à la console, donc 1.
Tout de suite après, j vaut 1. La valeur de « nombre » se rendra à 75, qui est impair. On
affiche donc le caractère dont le code ASCII est 97 + 1 – donc 98 -, soit ‘b’.
Tout de suite après, j vaut 2. La valeur de « nombre » se rendra à 90, qui est pair. On
affiche donc « j + 1 », donc 3.
L’affichage combiné de ces trois éléments est donc 1b3.

AFFICHAGE FINAL:
a
1b
1b3
QUESTION 3)
int nombre, a, borne, ajustementBorne;

nombre = 0;
bool nombreEstNul;
do{
nombreEstNul = nombre = = 0;
a = 1;
borne = nombreEstNul ? 3 : 0;
ajustementBorne = nombreEstNul ? -1 : 1;
while (a < 3) {
borne += ajustementBorne;
for (int i = 0; i < borne ; i++){
nombre += a;
Console.Write(nombre);
}
a++;
}
} while (nombre != 9);

L’affichage aura un total de quatre lignes.
Il n’y aura que des chiffres, et ils seront tous en ordre croissant.
Le nombre de chiffres aux lignes « d’extrémité » est deux fois plus grand que le nombre
de chiffres aux lignes « du milieu ».
SOLUTION :
nombre = 0
nombreEstNul = nombre = = 0  vrai
a=1
borne = 3 (car « nombreEstNul » est vrai)
ajustementBorne = -1 (car « nombreEstNul » est vrai)
Premier tour de boucle du while (s’exécute car « a » (qui est égal à 1) < 3) :
borne = 2
Premier tour de boucle du for :
nombre = 1
« nombre » est alors affiché à la console
Deuxième tour de boucle du for :
nombre = 2
Le for a donc affiché 12
Puis, saut de ligne
« a » est incrémenté de 1 à 2
Deuxième tour de boucle du while (s’exécute car a = 2 et 2 < 3) :

borne = 1 (car 2 += -1  1)
nombre = 4 (car 2 += 2  4)
Puis, saut de ligne
Troisième tour de boucle du while : NE S’EXÉCUTERA PAS CAR a = 3 et 3 N’EST

PAS INFÉRIEUR À 3
Vérification de la condition du « do-while » cette structure continue car nombre = 4 et 4 != 9

nombreEstNul = nombre = = 0  faux (car nombre = 4)
a=1
borne = 0 (car « nombreEstNul » est faux)
ajustementBorne = 1 (car « nombreEstNul » est faux)
Premier tour de boucle du while (s’exécute car a = 1 et 1 < 3) :
borne = 1
nombre = 5
Puis, saut de ligne
Deuxième tour de boucle du while (s’exécute car a = 2 et 2 < 3) :

borne = 2
nombre = 7
Deuxième tour de boucle du for :
nombre = 9
Puis, saut de ligne
Troisième tour de boucle du while : NE S’EXÉCUTERA PAS CAR a = 3 et 3 N’EST
PAS INFÉRIEUR À 3
Vérification de la condition du « do-while » cette structure S’ARRÊTE car nombre = 9 et il est

faux de dire que 9 != 9
AFFICHAGE FINAL:
12
4
5
79
QUESTION 4)
int nombre, a, borne, ajustementBorne;

nombre = -1;
bool nombreEstNegatifUnitaire;
while (nombre != 8){

nombreEstNegatifUnitaire = nombre = = -1;
borne = nombreEstNegatifUnitaire ? 3 : 0;
ajustementBorne = nombreEstNegatifUnitaire ? -1 : 1;
for(int i = 0; i < 2; i++){

borne += ajustementBorne;
a = 0;
do{
a++;
nombre += i + 1;
Console.Write(nombre);
} while (a < borne);
}
}

Exactement la même disposition que le problème précédent!
SOLUTION :
nombre = -1
Premier tour de boucle du « while » :
nombreEstNégatifUnitaire = nombre = = -1  vrai
borne = 3 (car « nombreEstNégatifUnitaire » est vrai)
ajustementBorne = -1 (car « nombreEstNégatifUnitaire » est vrai)
Premier tour de boucle du for (donc i = 0):
borne = 2
a=0
Premier tour de boucle du do-while :
a est incrémenté à 1
« nombre » passe de -1 à 0 et est alors affiché à la console
Le « do-while » continue car a (= 1) < borne (= 2)
« nombre » passe de 0 à 1 et est alors affiché à la console
Le « do-while » s’arrête car a (= 2) N’EST PAS plus petit que borne (= 2)
Le « do-while » a donc affiché 01
Saut de ligne
Deuxième tour de boucle du for (donc i = 1):

borne = 1
a=0
Puis, saut de ligne
Deuxième tour de boucle du while (s’exécute car nombre = 3 et 3 != 8) :

nombreEstNégatifUnitaire = nombre = = -1  faux car nombre = 3
borne = 0 (car « nombreEstNégatifUnitaire » est faux)
ajustementBorne = 1 (car « nombreEstNégatifUnitaire » est faux)
Premier tour de boucle du for (donc i = 0):
borne = 1
a=0
Saut de ligne
Deuxième tour de boucle du for (donc i = 1):

borne = 2
a=0
Le « do-while » continue car a (= 1) < borne (= 2)
Puis, saut de ligne
Le while s’arrête car nombre = 8 est 8 N’EST PAS != 8
AFFICHAGE FINAL:
01
3
4
68
QUESTION 5)
Comme ceci est la question #5…
Un des plus grands défenseurs de l’histoire du Canadien de Montréal portait le chandail

numéro #5 : Guy Lapointe (surnommé « Pointu »!) Il détient toujours le record d’équipe
du plus grand nombre de buts marqués en une saison par un défenseur, soit 28.
const int numeroDePointu = 28 % 5 + 2;

string s = "Programmer m’empêche de dormir!";
int a = 1;
int b = 9;
int nombreTemporaire, somme;
do {
for (int i = 0; i < b; i++){
Console.Write(s[i]);
somme = 0;
nombreTemporaire = a;
while (nombreTemporaire < numeroDePointu)
{
somme += nombreTemporaire;
nombreTemporaire++;
}
Console.Write(somme = = 0 ? "" : somme.ToString());
}
a++;
a++;
b++;
} while (a < b);
Un affichage sur un total de huit lignes. Il y a un certain mot qui sera important dans
l’affichage, qui apparaîtra en tout ou en partie à chaque ligne. Dans les deux premières
lignes, il sera « ventilé », en ce sens qu’entre chacune des lettres, un nombre sera inséré.
C’est toujours le même nombre sur une même ligne, mais ce n’est pas le même nombre
entre les lignes 1 et 2.
Dans les six dernières lignes, il n’y a plus de nombre, et il y a une certaine phrase qui
« s’allonge » de ligne en ligne.
SOLUTION :
1) Premier tour de boucle du « do-while »
Comme b = 9, le « for » tournera 9 fois. Ce for affiche donc les 9 premiers caractères de
la chaîne « s », les caractères aux positions 0 à 8, soit les caractères « Programme » (de la
chaîne « Programmer m’empêche de dormir! »).
Après avoir affiché chacun des caractères, le code initialise la « somme » à 0 et le

« nombreTemporaire » à « a ». « nombreTemporaire » vaut donc 1, ici. Il y a alors un
« while » qui roule tant que « nombreTemporaire » est plus petit que
« numeroDePointu » (donc 5), et tant que c’est le cas, la valeur de « nombreTemporaire »
est additionnée à « somme » (évidemment, « nombreTemporaire » est incrémenté à
chaque tour de boucle.).
Ici, « nombreTemporaire » commence à 1 et sera incrémenté jusqu’à atteindre 5. Ceci

stoppera le « while » puisqu’il est faux que 5 < 5. Donc les valeurs successives de
« nombreTemporaire » seront 1, 2, 3 et 4, et ce qui sera mis dans « somme » sera donc
1+2+3+4 = 10.
Une fois le « while » terminé, le code regarde si cette « somme » est égale à 0. Si oui, il
affiche une chaîne vide (donc après le caractère qu’il vient tout juste d’afficher quelques
lignes plus haut). Mais si cette somme est plus grande que 0, c’est alors cette somme qui
est affichée juste après le caractère.
On peut donc conclure que la première ligne s’affichant à la console, dans ce premier tour
de boucle du « do-while », est
P10r10o10g10r10a10m10m10e10
Après cet affichage, « a » est incrémenté deux fois (passe donc de 1 à 3) et « b » est
incrémenté une fois (passe donc de 9 à 10).
3 est-il plus petit que 10? Oui. On continue le « do-while ».
2) Deuxième tour de boucle du « do-while »
b = 10.
le « for » tournera donc 10 fois.
Ce for affiche donc les 10 premiers caractères de la chaîne « s », les caractères aux
positions 0 à 9, soit les caractères « Programmer ».
Qu’en est-il du « while », soit la possibilité d’afficher un nombre après chacun des
caractères? « nombreTemporaire » est initialisé à « a », soit 3. Le « while » va rouler
jusqu’à ce que « nombreTemporaire » atteigne 5, donc « nombreTemporaire » va prendre
tour à tour les valeurs 3 et 4 et « somme » finira par contenir 7. C’est donc ce nombre qui
sera affiché après chacune des lettres et la ligne s’affichant à la console est donc :
P7r7o7g7r7a7m7m7e7r7
3) Troisième tour de boucle du « do-while »
b = 11.
positions 0 à 10, soit les caractères « Programmer », avec l’espace après le « r ».
Qu’en est-il du « while »? Comme « nombreTemporaire » est initialisé à « a », soit 5, la

condition du while est immédiatement fausse, puisqu’il est faux que 5 < 5. La somme
n’est pas incrémentée avec des valeurs quelconques de « nombreTemporaire », elle
demeure à 0 et aucun nombre ne sera affiché après chacun des caractères.
La ligne s’affichant à la console est donc :
Programmer
(on ne voit pas l’espace après le dernier ‘r’)
4) Quatrième tour de boucle du « do-while »
b = 12.
positions 0 à 11, soit les caractères « Programmer m ».
Le « while » ne roule pas du tout : « nombreTemporaire » est initialisé à 7 et il est

évidemment faux que 7 < 5. Donc, aucun nombre affiché après chacun des caractères.
Programmer m
5) Cinquième tour de boucle du « do-while »
b = 13.
positions 0 à 12, soit les caractères « Programmer m’ ».
Le « while » ne roule pas : « nombreTemporaire » est initialisé à 9 et il est faux que 9 <
5. Aucun nombre affiché après chacun des caractères.
Programmer m’
6) Sixième tour de boucle du « do-while »
b = 14.
positions 0 à 13, soit les caractères « Programmer m’e ».
Le « while » ne roule pas : « nombreTemporaire » est initialisé à 11 et il est faux que 11

< 5. Aucun nombre affiché après chacun des caractères.
Programmer m’e
7) Septième tour de boucle du « do-while »
b = 15.
positions 0 à 14, soit les caractères « Programmer m’em ».

Programmer m’em
8) Huitième tour de boucle du « do-while »
b = 16.
positions 0 à 15, soit les caractères « Programmer m’emp ».

Programmer m’emp
17 est-il plus petit que 17? NON : FIN DU « do-while » ET DU CODE.

AFFICHAGE FINAL:
La console affiche donc en séquence :
P10r10o10g10r10a10m10m10e10
P7r7o7g7r7a7m7m7e7r7
Programmer
Programmer m
Programmer m’
Programmer m’e
Programmer m’em
Programmer m’emp
QUESTION 6)
Le même thème a guidé la rédaction de cette question.
Si GUY LApointe (« Pointu ») portait le chandail #5, un autre grand « GUY LA… »
jouait pour le Canadien à cette époque, soit GUY LAfleur, qui portait le chandail #10.
Lafleur avait hérité des surnoms de « Flower » et du « Démon blond ».
En fait, cette syllabe de « LA » était vraiment à l’honneur dans les éditions du Canadien
des années ’70 :
Michel LArocque : gardien de but, #1 (surnom : « Bunny »)
Yvon LAmbert : ailier gauche, #11
Rod LAngway : défenseur, #17
LArry Robinson : défenseur, #19 (surnom : « Big Bird »)
Pierre LArouche : centre, #28 (surnom : « Lucky Pete »)
(code à la page suivante)

const int numeroDePointu = 5;
const int numeroDuDemonBlond = 10;
string s = ″Programmer est dangereux pour ma santé!″;
int tailleChaine = s.Length;
const int numBunny = 1;
const int numLambert = 11;
const int numLangway = 17;
const int numBigBird = 19;
const int numLuckyPete = 28;
int[] lesAutresLa = {numBunny,numLambert,numLangway,numBigBird,numLuckyPete};
int indTablo_BorneInf = 0;
int nmbrDIter, compteurIterations;
int nombre = numeroDePointu;
while (nombre < numeroDuDemonBlond - 1){
nmbrDIter = lesAutresLa[indTablo_BorneInf+1] - lesAutresLa[indTablo_BorneInf];
compteurIterations = 0;
do{
for (int i = 0; i < tailleChaine - nombre;i++){
Console.Write(s[i]);
}
compteurIterations++;
} while (compteurIterations < nmbrDIter);
nombre++;
indTablo_BorneInf++;
}
CE À QUOI VOUS POUVEZ VOUS ATTENDRE : un assez long affichage de 27

lignes! Il n’y a strictement aucun chiffre dans cet affichage. La phrase présentée dans
l’énoncé du code est toujours présente dans chacune des lignes d’affichage, mais encore
une fois, avec un certain nombre de caractères qui ont été enlevés… mais cette fois-ci,
pas du même côté qu’à la toute première question!
Les 10 premières des 27 lignes sont identiques entre elles. Les 8 prochaines SEMBLENT
identiques entre elles, mais en réalité, il y un détail qui diffère entre les six premières et les deux
dernières (de ces huit). Finalement, les neuf dernières lignes sont identiques entre elles.
SOLUTION :
Avant le while…
La variable « nombre » est donc initialisée à « numeroDePointu », donc 5. Quant à l’expression

« numeroDuDemonBlond – 1 », elle sera toujours égale à 9 (rappelons que
« numeroDuDemonBlond » est une constante).
La variable « indiceDansTableau_BorneInferieure » est initialisée à 0.

1) Première évaluation de la condition booléenne du « while() » : vrai, car 5 < 9.
Comme indTablo_BorneInf = 0, « indTablo_BorneInf + 1 » = 1.
Donc, nmbrDIter = lesAutresLa[1] - lesAutresLa[0] = 11 – 1 = 10.
Ceci implique que le « do while() » va rouler 10 fois : « compteurIterations » est initialisé à 0, est
incrémenté dans le « do while() » et va donc rouler jusqu’à se rendre à 9; quand
« compteurIterations » atteindra 10, comme il est faux que 10 < 10, le « do while() » cessera.
À chaque tour de boucle de ce « do while() », la ligne qui s’affichera à la console est déterminée
par le « for » : il affichera des caractères jusqu’à ce que « i » soit inférieur à « tailleDeLaChaine
– nombre ». Comme ici, nombre = 5, cela veut dire que les 5 derniers caractères sont enlevés.
DONC, dans le premier tour de boucle du « while » initial, la phrase amputée de ses 5 derniers
caractères sera affichée 10 fois :
Programmer est dangereux pour ma s
Après cet affichage, « nombre » est incrémenté (passe donc de 5 à 6) et
« indTablo_BorneInf » aussi (passe donc de 0 à 1).
2) Première évaluation de la condition booléenne du « while() » : vrai, car 6 < 9.
Ceci implique que le « do while() » va rouler 6 fois.
Dans chacun des tours de boucle de ce « do while() », la ligne qui s’affiche est la chaîne « s »
amputée de ses 6 derniers caractères (puisque nombre = 6).
Ainsi, dans ce second tour de boucle du « while » initial, la phrase amputée de ses 6 derniers
Programmer est dangereux pour ma

TRÈS IMPORTANT : à la fin de chacune de ces 6 lignes, il y a une espace qui n’est pas visible à
la console!

3) Troisième évaluation de la condition booléenne du « while() » : vrai, car 7 < 9.

IMPORTANT : à la fin de chacune de ces 2 lignes, il n’y a PAS d’espace.

4) Quatrième évaluation de la condition booléenne du « while() » : vrai, car 8 < 9.
Donc, nmbrDIter = lesAutresLa[4] - lesAutresLa[3] = 28 - 19 = 9.
Programmer est dangereux pour m

5) Cinquième évaluation de la condition booléenne du « while() » : FAUX, car 9 = 9.
AFFICHAGE FINAL:
Le code prend donc fin, et l’affichage final à la console est :
Programmer est dangeureux pour ma s

Programmer est dangeureux pour ma
Programmer est dangeureux pour m
QUESTION 7)
Supposez que vous ayez accès à la méthode « EstConsonne(…) » qui prend en paramètre
un caractère et retourne vrai ou faux selon que ce caractère est un lettre et une consonne
(peu importe que la lettre soit minuscule ou majuscule). Indiquez alors ce que la console
affichera suite à l’exécution des structures de contrôle itératives suvantes.
string alphabet = "abcdefghijklmnopqrstuvwxyz";
int indiceDansAlphabet = -1;
char carac;
for (int i = 1; i <= 4; i++){
Console.Write(alphabet[i]);
do {
Console.Write("toto");
indiceDansAlphabet++;
carac = alphabet[indiceDansAlphabet];
while(EstConsonne(carac)){
Console.Write(carac);
indiceDansAlphabet++;
carac = alphabet[indiceDansAlphabet];
}
} while (EstConsonne(carac));
}

Quatre lignes d’affichage. Il y aura un certain mot (le même) apparaissant à chacune des
lignes, et il est toujours précédé d’un caractère. Il y a une certaine « progression » que
l’on peut observer pour ce caractère (entre les différentes lignes). Après le mot, ou bien il
n’y a rien du tout, ou bien il y a une série de lettres, et là encore on peut observer une
certaine progression entre toutes ces lettres.
SOLUTION :
indiceDansAlphabet = -1
Premier tour de boucle du « for » :

i=1
affichage de alphabet[1], soit la lettre b
exécution du do
Affichage de toto
indiceDansAlphabet passe de -1 à 0
caractere = alphabet[0] = a
le while ne sera PAS exécuté parce que « a » n’est PAS une consonne
Le do while s’arrête également pour la même raison : « a » n’est pas une consonne
Saut de ligne
Ce qui a été affiché dans ce 1ier tour de boucle du for est btoto
Deuxième tour de boucle du « for » :

i=2
affichage de alphabet[2], soit la lettre c
exécution du do
Affichage de toto
indiceDansAlphabet passe de 0 à 1
caractere = alphabet[1] = b
analyse du while : sera exécuté tant que les lettres (à partir du « b » de la
ligne précédente) sont des consonnes, donc affichera ici « bcd ». Lorsqu’on est
rendu à « e », le while s’arrête. « indiceDansAlphabet » a donc été incrémenté
trois fois et vaut maintenant 4.
Le do while s’arrête également pour la même raison : « e » n’est pas une consonne
Saut de ligne
Ce qui a été affiché dans ce 2ième tour de boucle du for est ctotobcd
Troisième tour de boucle du « for » :

i=3
affichage de alphabet[3], soit la lettre d
exécution du do
Affichage de toto
caractere = alphabet[5] = f
le while sera exécuté tant que les lettres parcourues (à partir du « f » de la

ligne précédente) sont des consonnes, donc affichera ici « fgh ». Lorsqu’on est
rendu à « i », le while s’arrête. « indiceDansAlphabet » a donc été incrémenté
trois fois et vaut maintenant 8.
Le do while s’arrête également pour la même raison : « i » n’est pas une consonne
Saut de ligne
Ce qui a été affiché dans ce 3ième tour de boucle du for est dtotofgh
Quatrième tour de boucle du « for » :

i=4
affichage de alphabet[4], soit la lettre e
exécution du do
Affichage de toto
caractere = alphabet[9] = j
encore une fois, le while sera exécuté tant que les lettres visitées (à partir du
« j » de la ligne précédente) sont des consonnes, donc affichera ici « jklmn ».
Lorsqu’on est rendu à « o », le while s’arrête. « indiceDansAlphabet » a donc
été incrémenté cinq fois et vaut maintenant 14.
Le do while s’arrête également pour la même raison : « o » n’est pas une consonne
Saut de ligne
Ce qui a été affiché dans ce 4 ième ET DERNIER tour de boucle du for est
etotojklmn
AFFICHAGE FINAL:
btoto
ctotobcd
dtotofgh
etotojklmn

7ExercicesDeBouclesImbriquees CORRIGE

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

7ExercicesDeBouclesImbriquees CORRIGE

Transféré par

Droits d'auteur :

Formats disponibles

QUESTION 1)

Soit le code suivant :

string s = ″Programmer me rend fou!″;

CE À QUOI VOUS POUVEZ VOUS ATTENDRE :

Voici la trace complète de ce code :

Deuxième tour de boucle du « do while » :

Troisième tour de boucle du for (i = 2):

Deuxième tour de boucle du « do while » :

Troisième tour de boucle du « do while » :

Programmer me rend fou!5

for (int i = 0; i < 3; i++){

CE À QUOI VOUS POUVEZ VOUS ATTENDRE :

Dans le « do while », la variable « nombre » est incrémentée, passant initialement de 0 à

Quand j vaut 0, la variable « nombre » sera incrémentée jusqu’à valoir 30 (rappel : on ne

30 étant pair, on affiche « j + 1 » à la console, donc 1.

L’affichage combiné de ces deux éléments est donc 1b.

Puis, saut de ligne.

Quand j vaut 0, la variable « nombre » sera incrémentée jusqu’à valoir 60.

60 étant pair, on affiche « j + 1 » à la console, donc 1.

L’affichage combiné de ces trois éléments est donc 1b3.

Puis, saut de ligne.

Soit le code suivant :

int nombre, a, borne, ajustementBorne;

CE À QUOI VOUS POUVEZ VOUS ATTENDRE :

Deuxième tour de boucle du while (s’exécute car a = 2 et 2 < 3) :

Troisième tour de boucle du while : NE S’EXÉCUTERA PAS CAR a = 3 et 3 N’EST

Vérification de la condition du « do-while » cette structure continue car nombre = 4 et 4 != 9

Deuxième tour de boucle du « do while » :

Deuxième tour de boucle du while (s’exécute car a = 2 et 2 < 3) :

Vérification de la condition du « do-while » cette structure S’ARRÊTE car nombre = 9 et il est

Soit le code suivant :

int nombre, a, borne, ajustementBorne;

while (nombre != 8){

for(int i = 0; i < 2; i++){

CE À QUOI VOUS POUVEZ VOUS ATTENDRE :

Deuxième tour de boucle du for (donc i = 1):

Deuxième tour de boucle du while (s’exécute car nombre = 3 et 3 != 8) :

Deuxième tour de boucle du for (donc i = 1):

Comme ceci est la question #5…

Un des plus grands défenseurs de l’histoire du Canadien de Montréal portait le chandail

const int numeroDePointu = 28 % 5 + 2;

CE À QUOI VOUS POUVEZ VOUS ATTENDRE :

1) Premier tour de boucle du « do-while »

Après avoir affiché chacun des caractères, le code initialise la « somme » à 0 et le

Ici, « nombreTemporaire » commence à 1 et sera incrémenté jusqu’à atteindre 5. Ceci

3 est-il plus petit que 10? Oui. On continue le « do-while ».

2) Deuxième tour de boucle du « do-while »

5 est-il plus petit que 11? Oui. On continue le « do-while ».

3) Troisième tour de boucle du « do-while »

Qu’en est-il du « while »? Comme « nombreTemporaire » est initialisé à « a », soit 5, la

La ligne s’affichant à la console est donc :

(on ne voit pas l’espace après le dernier ‘r’)

7 est-il plus petit que 12? Oui. On continue le « do-while ».

4) Quatrième tour de boucle du « do-while »

Le « while » ne roule pas du tout : « nombreTemporaire » est initialisé à 7 et il est

La ligne s’affichant à la console est donc :

9 est-il plus petit que 13? Oui. On continue le « do-while ».

5) Cinquième tour de boucle du « do-while »

La ligne s’affichant à la console est donc :

11 est-il plus petit que 14? Oui. On continue le « do-while ».

6) Sixième tour de boucle du « do-while »

Le « while » ne roule pas : « nombreTemporaire » est initialisé à 11 et il est faux que 11

13 est-il plus petit que 15? Oui. On continue le « do-while ».