Boucles imbriqués

Nous avons vu comment faire une boucle pour afficher la table de multiplication par 5

for (i=0 ; i<=10; ++i)

{

System.out.println(« 5 fois  » + i + « vaut » + 5*i) ;

}

Maintenant on veut faire une boucle qui affiche les tables de multiplication de 2 à 10 .

D’abord on veut afficher 8 trucs

donc on aura une boucle du type

for ( int j=2 ; j <=10 ; ++j)

{

instructions ;

}

Maintenant dans le bloc d’instruction :

for (int i = 0 ; i <= 10 ; ++i)

{

System.out.println(j + « fois  » + i + « vaut » + j*i) ;

}

 

et voila le tour est joue

 

Faire la somme des 4 notes – version amélioré –

Supposons que l’on veuille que ce soit l’utilisateur qui choisisse combien de note il veut entrer pour la moyenne

Code

System.out.println(« Entrez le nombre de notes que vous voulez calculer :  » );
int nombre_de_note = scanner.nextInt();

On a ainsi notre nombre de notes .

Cette fois ci il faut modifier la condition de la boucle

double somme = 0.0 ;

for (int i =1 ; i <= nombre_de_note ; ++i)

{

System.out.println(« entrez la note : »);
double note= scanner.nextDouble();
somme= somme + note ;

}

System.out.println(« La somme des 4 notes vaut  » somme / nombre_de_note) ;

PS :

Dans notre derniere ligne on a la division suivante somme / nombre_de_note

Imaginons que pour nombre_de_note l’utilisateur entre la valeur 0 .

On aura une erreur .

Une solution est de mettre une condition
Par exemple if(nombre_de_note > 0)

if(nombre_de_note >0 ) {

for (int i =1 ; i <= nombre_de_note ; ++i)

{

System.out.println(« entrez la note : »);
double note= scanner.nextDouble();
somme= somme + note ;

}

System.out.println(« La somme des 4 notes vaut  » somme / nombre_de_note) ;

}

Voila comme ça c’est bon

Faire une moyenne de 4 notes

On demande de calculer la moyenne de 4 notes .

Donc on doit avoir (note1+note2+note3+note4) / 4 .

Alors comment on code ?

Un moyen laborieux de faire consisterait :

Code

System.out.println(« Entrez la note i  » );
double note_i= scanner.nextDouble();

mouais et pour la somme des notes ?

on pourrait écrire :

double somme = 0.0 ;
somme = somme + note_i ;

Mais il existe une autre solution , la boucle for

Exemple

for ( int i=1 ; i<=4 ; ++i)

{

System.out.println(« Entrez la note : « ) ;
double note = scanner.nextDouble();
somme = somme + note ;

}

System.out.println(« La moyenne des 4 notes vaut  » + somme / 4.0 );

Alors que se passe-t-il ?

une boucle et une variable i qui va de 1 à 4 . Cette boucle va s’exécuter 4 fois .
Affiche : entrez la note
on entre la premiere note dans la variable note ex : 11
somme est affecte de la valeur somme + note = 0 + 11 =11
i vaut 2
etc…

a la fin de la boucle on a bien somme qui vaut la somme des 4 notes .

Exemple de boucle for

voici un code

for (int i=0 ; i < 5 ; ++i)

{

System.out.println(i);

if(i%2==0)

{

System.out.println(« p »);

}

System.out.println( » « );

}

alors que se passe-t-il ?

On a une boucle for .
i vaut 0 au départ , on entre dans la boucle .
On affiche i : 0
Branchement conditionnel
condition (i % 2==0) true
On affiche p
On affiche un espace
on revient sur la boucle
i est incrémenté , i vaut 1 .
on re-entre dans la boucle
On affiche i : 1 
Branchement conditionnel
Condition (i%2==0) false
on affiche un espace
on re-entre dans la boucle
i est incrémenté , i vaut 2 .

A la fin on a : 0p 1 2p 3 4p

Afficher une table de multiplication avec for

Je veux afficher la table de multiplication de 5

5 fois 1 vaut 5
5 fois 2 vaut 10
5 fois 3  vaut 15
etc …
5 fois 10 vaut 50

on pourrait faire 10 system.out.println(« 5 fois 1 vaut 5 »);

non
On veut répéter un truc 10 fois
On a une variable i qui va de 1 à 10 .

for ( int i = 1 ; i <= 10  ;   ++i )

{

System.out.println(« 5 fois » + i +  « vaut  » + 5*i) ;

}

Quelques exemples de boucles

Exemple 1

for ( int j = 0 ; j < 5; ++j)

{

System.out.println(j);

}

0
1
2
3
4

Exemple 2

for (int j=0 ; j < 10 ; j +=2)

{

System.out.println(j/2);

}

0
1
2
3
4

Exemple 3

for ( int i =0 ; i> 5 ; –i)

{

System.out.println(i);

}

i vaut 0 , on teste la condition 0>5 false
La boucle s’arrête .

La boucle for

Elle permet de répéter des trucs

 

for ( Déclaration_et_initialisation ; condition ;icrémentation ) 

{

Bloc d’instructions ;

}

Exemple 

for (int i=0 ; i< 10 ; ++i)

{

System.out.println(i);

}

i vaut 0 , on teste la condition 0<10 true , on entre dans la boucle
Affiche i : 0
On incrémente : ++i , i vaut 1 .
i vaut 1 , on teste la condition 1< 10 , on entre dans la boucle
Affiche i : 1
etc …
On incrémente : ++i , i vaut 10
i vaut 10 , on teste la condition 10 < 10 false
La boucle s’arrête

Output

0
1
2
3
4
5
6
7
8
9

Devoir 1 , semaine 2

Le but de cet exercice est d’écrire un programme Java posant des questions à l’utilisateur pour deviner à quel personnage (parmi une liste connue à l’avance) pense l’utilisateur.

Le programme ne peut poser que des questions dont la réponse est oui ou non (l’utilisateur répondra aux questions du programme par false pour non, et par true pour oui ; voir l’exemple de déroulement fourni plus bas).

Les 5 personnages possibles sont: M^lle Rose, le Professeur Violet, le Colonel Moutarde, le Révérend Olive et M^me Leblanc.

Seul le Colonel Moutarde a des moustaches, tous portent des lunettes sauf M^lle Rose, et le Professeur Violet est le seul à avoir un chapeau.

 

Correction :

 

import java.util.Scanner;

class Cluedo1 {

private static Scanner clavier = new Scanner(System.in);

public static void main(String[] args) {

System.out.print(« Pensez a un personnage : Mlle Rose, « );
System.out.println(« le Professeur Violet, le Colonel Moutarde, »);
System.out.println(« le Reverend Olive ou Mme Leblanc.\n »);

System.out.print(« Votre personnage a-t-il des moustaches ? « );
System.out.print(« (true : oui, false : non) « );
boolean moustaches = clavier.nextBoolean();

System.out.print(« Votre personnage porte-t-il des lunettes ? « );
boolean lunettes = clavier.nextBoolean();

System.out.print(« Votre personnage porte-t-il un chapeau ? « );
boolean chapeau = clavier.nextBoolean();

System.out.print(« Est-ce que votre personnage est un homme ? « );
boolean homme = clavier.nextBoolean();

System.out.print(« ==> Le personnage auquel vous pensez est « );

if (chapeau) {
/*******************************************

• Completez le programme a partir d’ici.

*******************************************/
System.out.print(« le Professeur Violet »);
}

else if(moustaches)
{
System.out.print(« le Colonel Moutarde »);

}
else if(lunettes & homme)
{

System.out.print(« le Reverend Olive »);
}
else if(lunettes && !homme)
{
System.out.print(« Mme Leblanc »);

}
else {

System.out.print(« Mlle Rose »);

/*******************************************

• Ne rien modifier apres cette ligne.

*******************************************/
}

System.out.println();
}
}

 

#le

Exercice 7

Le but de cet exercice est de tester des expressions mathématiques.

Expression 1

Cette expression est définie sauf en zéro , en effet 1-exp(0)=1-1=0

D’ou comment la coder ??

if ( x ==0.0)

{

System.out.println(« expression non définie);

}

else

{

 double expression1= x / ( 1.0-Math.exp(x) ) ;

}

Expression 2

On a x > 0 et x doit etre different de 1 d’ou x doit etre x est definie sur ]0;1[ U ]11;+ infini [

code

if  ( x <= 0.0 || x==1.0)

{

meme bloc d’instructions que plus haut

}

Expression 3

• est definie sur [8; +infini [

Exercice 2 , Semaine 2

On demande d’écrire un programme qui teste si un réel x appartient à l’intervalle suivant :

I=[2,3[ U ]0,1] U [-10,-2]

Je crée mon squelette

Maintenant comment tester si x appartient à I ?

if (     ( x >= 2.0 && x <3.0 ) ||  ( x > 0.0 &&  x < =1.0 )   || (  x >= -10.0  &&  x <= -2.0 )   )

Non ?? bon ou pas bon ??

Supposons x=-20

On a False || False || False —-> False

En fait c’est bon .

Difficulté supplémentaire , n’utiliser les opérateurs relationnels < et ==

donc comment réécrire cette condition ??

Rappel sur relation d’ordre : x < y ssi x <=y && !(x==y)

Reprenons point par point

( x >= 2.0) équivaut à !( x< 2.0)

(x > 0.0) équivaut à ( !(x < 0.0) && !(x==0.0) )

( x <= 1.0) equivaut à ( x <1.0) || (x==1.0)

(x >= -10.0 ) équivaut à !(x < -10.0)

(x <=-2.0) équivaut à !( x < -2.0) || !(x == -2.0)