| précédent | sommaire | accueil | suivant |
EXERCICE 1 afficher une saisie
Ecrire un programme qui demande à l' utilisateur de saisir un nom au clavier. Puis le programme affiche bonjour suivi du nom de la personne.
CORRECTION 1 :
1. public class Exercice1
2. {
3. public static void main (String [] args)
4. {
5.
6. System.out.println("Saisissez votre nom : ");
7. String nom = Lire.chaine();
8. System.out.println("Bonjour " + nom);
9.
10. }
11. }
A l' affichage : Bonjour nom nom étant le nom que vous avez tapé au clavier
EXERCICE 2 : afficher une saisie
Ecrire un programme qui demande à l' utilisateur de saisir le mot monsieur ou madame. Ensuite, il devra saisir son nom. Puis le programme affiche
Bonjour suivi de monsieur ou madame selon la saisie suivi du nom saisi
CORRECTION 2 :
1. public class Exercice2
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Saisissez le mot monsieur ou madame : ");
6. String civilite = Lire.chaine();
7. System.out.println("Saisissez votre nom : ");
8. String nom = Lire.chaine();
9.
10. System.out.println("Bonjour " + civilite + " " + nom);
10. }
11. }
A l' affichage : Bonjour civilite nom civilite et nom étant le nom que vous avez tapé au clavier
EXERCICE 3 afficher une table de multiplication
Ecrire un programme qui demande à l' utilisateur d' entrer un nombre entier. Puis le programme affiche la table de multiplication de ce nombre de
0 à 10
CORRECTION 3 :
1. public class Exercice3
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Saisissez un nombre entier : ");
6. int nombre = Lire.entierInt();
7.
8. for(int i = 0; i <= 10; i++)
9. {
10. System.out.println(nombre + " fois " + i + " = " + (nombre * i));
10. }
11. }
11. }
après compil et si vous entrez le nombre 5, il sera affiché :
5 fois 0 = 0
5 fois 1 = 5
5 fois 2 = 10
5 fois 3 = 15
5 fois 4 = 20
5 fois 5 = 25
5 fois 6 = 30
5 fois 7 = 35
5 fois 8 = 40
5 fois 9 = 45
5 fois 10 = 50
ligne 5 : le programme affiche un message demandant à l' utilisateur de saisir un nombre. ligne 6 : le programme affecte la variable nombre de type int
de la valeur saisie au clavier. Enfin la boucle affiche 11 fois (de zéro à 10 car i <= 10 veut dire i inférieur ou égal) la table de 5. Je vous
rappele si besoin est que la fonction System.out.println() affiche tel quel ce qui est entre double crochets (" ") et affiche le contenu de la
variable qui n' est pas entre crochet. Et je rappelle que nombre * i veut dire nombre multiplié par i.
EXERCICE 4 : utiliser l' instruction continue
Ecrire un programme qui affiche l' inverse des nombres entiers allant de -3 à +3.
CORRECTION 4 :
1. public class Exercice4
2. {
3. public static void main (String [] args)
4. {
5. for(double i = -3; i <= 3; i++)
6. {
7. System.out.println("inverse de " + i + " = " + (1 / i) );
8. }
9.
10. }
11. }
compilez ce programme. Aucun message d' erreur. Mais essayez de l' exécuter. Un message d' erreur s' affiche :
Exception in thread "main" java/lang.ArithmeticException : /zero
Ce qui veut dire : une erreur s' est produite dans la fonction main(). Une erreur de type arithmetique : division par zéro.
En effet, l' inverse de zéro n' existe pas. Car la division par zéro est impossible. Que faire pour résoudre le problème alors ? On peut afficher
les inverses de tous les nombres sauf zéro. Allons-y !
CORRECTION 4bis :
1. public class Exercice4bis
2. {
3. public static void main (String [] args)
4. {
5.
6. for(double i = -3; i <= 3; i++)
7. {
8. if(i == 0)
9. {
10. continue;
11 }
12. System.out.println("inverse de " + i + " = " + (1 / i) );
13.
14. }
15.
16. }
17. }
Cette fois, ça marche. Il s' affiche :
inverse de -3 = -0.333333333333
inverse de -2 = 0.5
inverse de -1 = -1.0
inverse de 1 = 1.0
inverse de 2 = 0.5
inverse de 3 = 0.333333333333
Vous voyez. Aucun message d' erreur. Les inverse des nombres allant de -3 à +3 s' affichent. Sauf celui de 0. Pourquoi ? A cause des lignes 8 à
11. Ligne 8 : si i est égal à zéro, ligne 10 : passe ton chemin. Autrement dit, ne fais rien du tout. L' instruction continue s' utilise
exclusivement dans une boucle (for, while ou do...while). Elle permet d' ignorer une ou plusieurs valeurs de la variable compteur. Ici, i
Vous avez remarqué, j' ai utilisé le type double pour la variable i. Si j' utilise le type int, j' obtiens en affichage, des valeurs int. 0 au
lieu de 0.33333333, 0 au lieu de 0.5. Pour 1, j' obtiens 1. L' inverse d' un type int est un type int.
EXERCICE 5 : afficher le carré d' une série de nombres
Ecrire un programme qui affiche le carré des nombres entiers pairs allant de 0 à 10 inclus
CORRECTION 5 :
1. public class Exercice5
2. {
3. public static void main (String [] args)
4. {
5.
6. for(int i = 0; i <= 10; i++)
7. {
8. if(i % 2 == 1)
9. {
10. continue;
11 }
12. System.out.println("carré de " + i + " = " + (i * i) );
13.
14. }
15.
16. }
17. }
compilation puis exécution donnent à l' affichage :
carré de 0 = 0
carré de 2 = 4
carre de 4 = 16
carré de 6 = 36
carré de 8 = 64
carré de 10 = 100
Nous voulons les carrés des nombres pairs. Alors nous disons (ligne 8 à 12) que si le reste de la division de i par 2 est égale à 1 (i % 2 == 1)
Ce qui veut dire que si i est impair, que le programme ne fasse rien du tout. D' où l' affichage de seulement les carrés des nombres pairs. Pigé?
EXERCICE 6 : trier un nombre au hasard dans un intervalle précis.
Ecrire un programme qui affiche au hasard un nombre entier compris entre 0 et 50. Puis le programme affiche au hasard un nombre compris entre 11
et 25. Puis le programma affiche un nombre au hasard entre - 10 et + 25.
CORRECTION 6 :
1. public class Exercice6
2. {
3. public static void main (String [] args)
4. {
5. int nombre050 = (int) (Math.random() * 51);
6. System.out.println("nombre au hasard entre 0 et 50 = " + nombre050);
7. System.out.println();
8. int nombre1124 = (int)( (Math.random() * 15) + 11);
9. System.out.println("nombre au hasard entre 11 et 24 = " + nombre1124);
10. System.out.println();
11 int nombre_1025 = (int)((Math.random() * 35) -10);
12.
13.
14. }
15.
16. }
17. }
Math.random() fournit un nombre pris au hasard dans l' intervalle fermée à 0 et ouvert à 1. Si on multiplie Math.random() par 51, on obtient un nombre pris au hasard entre 0 et 50, puisque l' intervalle est ouvert à 50. Entre 11 et 25, on prend l' intervalle [0, 15[ qui est le produit de [0, 1[ par 15. Puis on ajoute 11 pour obtenir l' intervalle [11, 26[, on obtient alors un nombre entre 0 et 25. Même raisonnement pour la suite. Evidement, le "(int)" est l' opération de casting pour récupérer seulement la partie entière.
**********
EXERCICE 7 : trier 2 nombres au hasard
Ecrire un programme qui affiche deux nombres entiers pris au hasard entre 0 et 50 avec la condition que l' un doit forcément être le double de
l' autre.
CORRECTION 7 :
1. public class Exercice7
2. {
3. public static void main (String [] args)
4. {
5. int a, b;
6. do
7. {
8. a = (int)(Math.random() * 51);
9. b = (int)(Math.random() * 51);
10. }
11 while( !(a == 2b) && !(b == 2a) )
12.
13. System.out.println("valeur de a = " + a + " et valeur de b = " + b);
14.
15.
16. }
17. }
compilez puis exécutez. Il sera affiché une valeur de a égale au double de celle de b ou à la moitié de celle de b.
Explication du code :
Il est évident que je dois déclarer les variable de type int (les nombres entiers) avant la boucle. Car si je les déclare à l' intérieur, elles
disparaîtront en sortie de cette boucle. Le programme doit afficher au hasard deux nombres entiers tel que l' un est forcément le double de
l' autre. Puisque les nombres sont triés au hasard. Il peut arriver qu' au premier tri, les conditions a = 2 * b (a = 2 fois b) ou b = 2 *a ne
soient pas vérifiées. Donc à priori -je dirais même à fortiori-, l' affectation de ces nombres au hasard se fera plusieurs fois. Donc, ce sera
une boucle. La boucle for ? Non ! parce qu' on ne connait pas le nombre de fois se fera le tri. Donc les boucles while ou do...while sont
requises. Pourquoi pas while ? Parce que la conditions a = 2 * b ou b = 2 * a ne peut être vérifiée que si a et b sont déjà affectés. Donc, il
faut affecter des valeurs à a ou à b au moins une fois. D' où la boucle do...while.
Le programme entre donc dans la boucle do...while. do (faire) : affecter une valeur entière prise au hasard entre 0 et 50 à a et à b. Puis les
conditions a = 2 fois b ou b = 2 fois b. En langage java, on écrit (a == 2 * b) || (b == 2 * a). le signe || veut dire ou en java. En fait, si on
écrit while( (a == 2 * b) || (b == 2 * a) ), on se serait trompé. Parce que la répétition se fait si cette condition booléenne est vérifiée. Or,
on veut que le programme sorte de la boucle si a = 2 fois b ou la réciproque. On doit alors écrire que tant que cette condition n' est pas
vérifiée, que la boucle continue. Donc, while( !( (a == 2 * b) || (b == 2 * a) ) ). Observez bien les parenthèses. Entre la deuxième parenthèse
ouverte et l' avant-dernière fermée, se trouve la condition a égale 2 fois b ou la réciproque. Puis nous mettons le point d' exclamation pour
signifier le contraire. Ce qui veut dire alors, tant que cette condition n' est pas vérifiée, que la boucle continue. Et c' est parce que à un
moment donné, a = 2 fois b ou la réciproque qu' on sort enfin de la boucle.
Au lieu de mettre cette forme while( !( (a == 2 * b) || (b == 2 * a) ) ) , j' ai choisi de mettre une forme simplifiée équivalente. Vous
savez que non (p ou q) = non p et non q. D' où la ligne 11.
Je sais, c' est peut-être trop long comme explication. Mais avec un peu d' effort, vous n' aurez pas du mal à comprendre. Voyons d' autres
exemples.
EXERCICE 8 : mettre fin au programme grâce à une saisie
Ecrire un programme qui demande à l' utilisateur d' entrer un caractère Puis le programme affiche ce caracère. Ainsi de suite !
Le programme s' arrête seulement si l' utilisateur entre le caractère 't'. A ce moment, le programme affiche : fin du programme.
CORRECTION 8 :
1. public class Exercice8
2. {
3. public static void main (String [] args)
4. {
5. char c;
6. do
7. {
8. System.out.println("saisissez un caractère. Pour terminer, saisissez 't' :");
9. c = Lire.caractere();
10. System.out.println("le caractère est : " + c);
11. }
12 while(c != 't');
13.
14. System.out.println("Donc, fin du programme");
15.
16. }
17. }
Faire (do) lignes 8 à 10 tant que la valeur de la variable c est différent de t. Dès que le caractère saisi est t, fin du programme. Je rappelle que Lire.caractere() est la méthode permettant de saisir un caractère.
**********
EXERCICE 9 : la maximum d' une série de valeurs entrées au clavier
Ecrire un programme qui demande à l' utilisateur de saisir une série de nombres entiers positifs. Pour arrêter la saise, on entre la valeur zéro.
Puis le programme affiche la plus grande des valeurs.
CORRECTION 9 :
1. public class Exercice9
2. {
3. public static void main (String [] args)
4. {
5. int saisie, maxi = 0;
6. do
7. {
8. System.out.println("Entrez un nouvel entier positif non nul :");
9. saisie = Lire.entierInt();
10. maxi = Math.max(maxi, saisie);
11. }
12 while(saisie != 0);
13. System.out.println("Vous avez saisie 0. fin de saisie. ");
14. System.out.println("valeur maximale saisie = " + maxi);
15.
16. }
17. }
Ligne 5 : on peut déclarer plus variables de même type et affecter seulement certains d' entre elles. les variables saisie et maxi sont déclarées
Mais la variable maxi est affectée. De même, on peut écrire ceci : int var1, var2 = 25, var3 = 125; On peut aussi écrire ceci : int var1, var2
= 14; var3; Il y aura toujours un seul point virgule pour terminer l' instruction. Lorsqu' on déclare plusieurs variables de même type dont
certaines sont affectées, il vaut mieux commencer par les variables non affectées puis terminer par celles qui sont affectées. Question de clarté.
Pas une obligation. Donc, ceci : int var1, var2 = 14; var3; pas trop conseillé.
Revenons au code. Ligne 8, pas besoin de vous expliquer. Ligne 9 aussi. Mais ligne 10 : la variable maxi a été initialisée (ligne 5) par la
valeur 0. Ici, on lui affecte le plus grand des nombres entre sa valeur à cet instant et celle de la saisie. Quand le programme revient pour la
deuxième fois dans la boucle, Math.max() compare toujours la nouvelle valeur de maxi et la saisie et affecte à maxi le plus grand des deux. De
sorte que maxi aura toujours la plus grande valeur de la saisie.
Pas la peine de vous dire ce qui sera affiché. Tout dépend de vos saisies.
EXERCICE 10 : le minimu d' une série de valeurs
Ecrire un programme qui demande à l' utilisateur de saisir une série de nombres entiers positifs. Pour arrêter la saise, on entre la valeur zéro.
Puis le programme affiche la plus petite des valeurs.
CORRECTION 10 :
1. public class Exercice10
2. {
3. public static void main (String [] args)
4. {
5. int saisie, mini = 0;
6. do
7. {
8. System.out.println("Entrez un nouvel entier positif non nul :");
9. saisie = Lire.entierInt();
10. mini = Math.min(mini, saisie);
11. }
12 while(saisie != 0);
13. System.out.println("Vous avez saisie 0. fin de saisie. ");
14. System.out.println("valeur minimale saisie = " + mini);
15.
16. }
17. }
Si vous compilez puis exécutez ce programme, la valeur affichée sera toujours égale à 0. Quelque soient les valeurs saisies. Et pour cause, 0
est toujours inférieur à tout nombre entier positif non nul. Et si vous refusez d' initialiser à zéro, vous aurez quand même à taper 0 pour
terminer la saisie. Et donc, c' est toujours 0 qui sera affiché.
Cet exemple, pour vous montrer que ce n' est pas parce que 2 énoncés se ressemblent à une petite différence près qu' il faut aller modifier la
partie du code mentionnant cette différence pour que tout fonctionne à merveille. Ici, j' ai changé le nom de la variable et la fonction
Math.max() en Math.min(). Cela n' a pas suffit. Comment faire alors ?
Procéder à une première saisie avant la boucle. Ainsi, on a une première valeur de mini qui n' est pas nulle. Mais attention, si la dernière
valeur entrée est égale à zéro (pour terminer la saisie), la valeur minimale affichée sera encore et toujours égale à 0. Que faire ? Demander
au programme de sortir de la boucle si la valeur saisie est égale à 0. Ainsi, cette valeur ne sera pas considéré comme l' une des saisie et ne
sera donc pas comparée dans Math.min(). Bon, trève de bavardages. Tapons le code adéquat
CORRECTION 10Bis :
1. public class Exercice10Bis
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Entrez un nouvel entier positif non nul :");
6. int saisie = Lire.entierInt(); int mini = saisie;
7. do
8. {
9. System.out.println("Entrez un nouvel entier positif non nul :");
9. saisie = Lire.entierInt();
10. if(saisie == 0)
11. {
12. break;
13. }
14. mini = Math.min(mini, saisie);
15. }
16 while(saisie != 0);
17. System.out.println("Vous avez saisie 0. fin de saisie. ");
18. System.out.println("valeur minimale saisie = " + mini);
19.
20. }
21. }
Cette fois, ça marche. La première valeur de mini est aussi la première valeur de saisie. Puis les lignes 10 à 13 indiquent que si la valeur
saisie est égale à zéro ( if(saisie == 0) ), le programme doit sortir de la boucle (break;). L' instruction break permet de sortir de la boucle.
Ainsi, la variable mini ne sera pas comparée à zéro par la méthode Math.mini().
A l' affichage, la valeur minimale ne sera jamais égale à zéro.
EXERCICE 11 : somme d' une série de valeurs entrées au clavier
Ecrire un programme qui demande à l' utilisateur de saisir une série de nombres entiers positifs. Pour arrêter la saise, on entre la valeur zéro.
Puis le programme affiche la somme des valeurs.
CORRECTION 11 :
1. public class Exercice11
2. {
3. public static void main (String [] args)
4. {
5. int saisie, somme = 0;
6. do
7. {
8. System.out.println("Entrez un nouvel entier positif non nul :");
9. saisie = Lire.entierInt();
10. somme += saisie;
11. }
12. while(saisie != 0);
13. System.out.println("Vous avez saisie 0. fin de saisie. ");
14. System.out.println("Sommes des valeurs saisies = " + somme);
15. }
16. }
explication des lignes 8 à 10 : on vous demande d' entrer une nouvelle valeur (ligne 8), vous l' entrez (ligne 9), puis on affecte à la variable somme, son ancienne valeur (zéro, voir ligne 5) + la valeur saisie. Rappel : somme += saisie; <=> somme = somme + saisie; Donc, ancienne valeur de somme = nouvelle valeur de somme + valeurde saisie. Ainsi de suite, on accumule la somme des valeurs jusqu' à la fin de la saisie. D' où l' affichage de la somme.
*********
EXERCICE 12 : moyenne d' une série de valeurs entrées au clavier
Ecrire un programme qui demande à l' utilisateur de saisir une série de nombres réels non nuls. Pour arrêter la saise, on entre la valeur zéro.
Puis le programme affiche la moyenne des valeurs. Attention, la valeur zéro entrée pour terminer la saisie ne fera pas partie de la saisie.
CORRECTION 12 :
1. public class Exercice12
2. {
3. public static void main (String [] args)
4. {
5. int nombreDEsaisies = 0; double saisie, somme = 0, moyenne = 0;
6. do
7. {
8. System.out.println("Entrez un nouveau nombre non nul :");
9. saisie = Lire.reelDouble();
10. if(saisie == 0)
11. {
12. break;
13. }
14. nombreDEsaisies++;
15. somme += saisie;
16. moyenne = somme/nombreDEsaisies;
17. }
18. while(saisie != 0);
19. System.out.println("Vous avez saisie 0. fin de saisie. ");
20. System.out.println("Moyenne des saisies = " + moyenne);
21. }
22. }
ligne 5 :
Le nombre de saisies est toujours un entier. D' où int nombreDEsaisies. Et il est initialisé à zéro. A ce stade, pas encore de saisie. Les
saisies sont des nombres réels. D' où le type double. On est aussi obligé de déclarer la somme et la moyenne entype rééel car leurs valeurs
dépendent de celles des saisies. somme des doubles = double. moyenne est de type double divisé par int (nombre de saisies) : donc, de type
double.
Si la saisie est égale = zéro, on sort de la boucle sans exécuter les instructions des lignes 14 à 16. Normal, à cause de break (ligne 12).
Sinon, le nombre de saisies est incrémenté de 1 (ligne 14), à la somme, on ajoute la valeur de la nouvelle saisie (ligne 15). Puis la moyenne
évidement est le rapport entre la somme et le nombre de saisies.
EXERCICE 13 : Nombre secret
Ecrire un programme qui tire au hasard un nombre entier compris entre 1 et 10. Ce nombre (secret) n' est pas affiché. Puis le programme
demande à l' utilisateur d' entrer un nombre entier au hasard entre 1 et 10. Si le nombre de l' utilisateur est supérieur au nombre secret,
le programme lui indique en lui demandant d' entrer un nouveau nombre. De même si le nombre est inférieur. Puis, lorsque l' utilisateur trouve,
le programme lui dit qu' il a gagné en lui indiquant le nombre de fois qu' il lui a fallu pour trouver le nombre.
CORRECTION 13 :
1. public class Exercice13
2. {
3. public static void main (String [] args)
4. {
5. int nombreSecret = (int) ( (Math.random() * 10) + 1);
6. int saisie, nombreDEfois = 0;
7. do
8. { System.out.println("Devinez le nombre secret. Entrez un entier entre 1 et 10 : ");
9. saisie = Lire.entierInt();
10. nombreDEfois++;
11. if(saisie == nombreSecret)
12. {
13. break;
14. }
15. else if (saisie > nombreSecret)
16. {
17. System.out.println("Trop grand. Veuillez recommencer");
18. }
19. else
20. {
21. System.out.println("Trop petit. Veuillez recommencer");
22. }
23. }
24. while(saisie != nombreSecret);
25. System.out.println("Vous avez trouvé, bravo !");
26. System.out.println("Il vous a fallu " + nombreDEfois + " fois pour trouver le nombre " + nombreSecret);
27. }
28. }
Ligne 5 : on affecte à la variable nombreSecret un nombre entier compris entre 1 et 10. Ligne 6 : on déclare la variable saisie et la variable
nombreDefois dans laquelle le nombre de saisies sera affecté.
ligne 9 : l' utilisateur saisie un nombre qui est alors affectée à la variable saisie. Ligne 10 : le nombre de fois (nombreDEfois++) passe de
zéro à 1. Puisque ++ veut dire incrémentation de 1. Si le nombre saisie est égal au nombre secret (ligne 11), alors, le programme sort de la
boucle. Normal, puisque l' utilisateur aura deviné le nombre secret.. Sinon, si ce nombre est supérieur au nombre secret (ligne 15) ou si ce
nombre est inférieur au nombre secret (ligne 19), alors, il s' affiche le message qui vous demande de recommencer (ligne 17 ou 21). Et ceci,
tant que la saisie est différente du nombre secret(ligne 24).
EXERCICE 14 : résoudre une équation du second dégré à une inconnue
Ecrire un programme qui permet de résoudre une équation de 2nd dégré à une inconnue : ax2 + bx + c. L' utilisateur entre les trois
paramètres de l' équation : a, b et c. Puis le programme affiche la solution.
CORRECTION 14 :
1. public class Exercice14
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Ce programme va résoudre votre équation du 2nd dégré à une inconnue :" );
6. System.out.println("Entrez le premier parametre : ");
7. double a = Lire.reelDouble();
8. System.out.println("Entrez le deuxieme parametre : ");
9. double b = Lire.reelDouble();
10. System.out.println("Entrez le troisieme parametre : ");
11. double c = Lire.reelDouble();
12. double delta = (b * b) - (4 * a * c);//déclaration et affectation du discriminant
13. double s = (- b / 2 * a), s1 = (- b - Math.sqrt(delta))/ (2 * a);
14. double s2 = (- b + Math.sqrt(delta))/ (2 * a);
15. if(delta == 0)
16. {
17. System.out.println("Une seule solution S = { " + s + " }" );
18. }
19. else if (delta > 0)
20. {
21. System.out.println("Deux solutions : S = { " + s1 + ", " + s2 + " }");
22. }
23. else
24. {
25. System.out.println("Pas de solutions pour cette equation");
26. }
27. }
28. }
Si vous savez résoudre une équation du second dégré à une inconnue, je n' ai pas grand chose à vous expliqeur ici. Suaf vous rappeler ce qu' est
le discriminant (ligne 12). Et aussi, je vous rappelle que Math.sqrt() est une fonction qui fournit la racine carrée du nombre qui se trouve dans
ses parenthèses. Ligne 13, c' est racine carrée de delta.
Mais ce programme n' est pas très bon. Imaginez que l' utilisateur entre le nombre zéro par accident. Ce programme n' a pas prévu ce cas là. Pire
encore, imaginez que les 3 paramètres a, b et c soient le résultat d' autres calculs effectués par le programme ou pire encore un autre programme.
On en est pas encore là. Mais sachez d' ores et déjà qu' il peut arriver que plusieurs programmes tournent sur la même plate forme. On appelle
le multi-thread. Donc, vous ne pouvez même pas savoir les valeurs de ces paramètres. Donc, il faut prévoir tous les cas. Programme suivant !
CORRECTION 14bis :
1. public class Exercice14bis
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Ce programme va résoudre votre équation du 2nd dégré à une inconnue :" );
6. System.out.println("Entrez le premier parametre : ");
7. double a = Lire.reelDouble();
8. System.out.println("Entrez le deuxieme parametre : ");
9. double b = Lire.reelDouble();
10. System.out.println("Entrez le troisieme parametre : ");
11. double c = Lire.reelDouble();
12.
13. if(a == 0) // si a = 0
14. {
15. if(b == 0) // a toujours = 0 et b = 0
16. {
17. if(c == 0) //c, toujours = 0 et b toujours = 0 et c = 0
18. {
19. // alors, la soultion = ensemble R
20. System.out.println("Solution S = { R } ");
21. }
22. else // a = 0, b = 0 et c différent de 0
23. {
24. System.out.println("Pas de solution");
25. }
26. }
27. else // ici, a = 0 et b différent de 0
28. {
29. System.out.println("une seule solution. S = { " + (-c / b) + " }");
30. }
31. }
32. else // ici a est différent de zéro. Donc, cas de la correction 14
33. {
34. double delta = (b * b) - (4 * a * c);//déclaration et affectation du discriminant
35. double s = (- b / 2 * a), s1 = (- b - Math.sqrt(delta))/ (2 * a);
36. double s2 = (- b + Math.sqrt(delta))/ (2 * a);
37. if(delta == 0)
38. {
39. System.out.println("Une seule solution S = { " + s + " }" );
40. }
41. else if (delta > 0)
42. {
43. System.out.println("Deux solutions : S = { " + s1 + ", " + s2 + " }");
44. }
45. else
46. {
47. System.out.println("Pas de solutions pour cette equation");
48. }
49. }
50. }
51. }
Tester le programme en saisissant les paramètres a, b, c correspondant à tous les cas. Les commentaires que j' ai mis vous permettront de
comprendre. Puis si vous savez résoudre une équation du second dégré à une inconnue, vous comprendrez encore plus. Rien de nouveau. Sauf sans
doute, les if imbriqués. Des if else à l' intérieur des if et else. Rien d' effrayant sauf en apparence. Remplacer if par si, else if par sinon,
si et else par sinon. Et la compréhension de ce programme n' aura rien de magique.
Lorsque nous apprendrons à écrire nos propres fonctions, ce problème sera résolu de façon plus aisée et le code sera plus clair car moins de
lignes.
EXERCICE 15 : Nombre de jours dans un mois.
Ecrire un programme qui demande à l' utilisateur de saisir le mois et l' année. Puis le programme affiche le nombre de jours de ce mois.
Rappel : Janvier, Mars, Mai, Juillet, Août, Octobre et Décembre ont toujours 31 jours quelque soit l' année.
Avril, Juin, Septembre et Novembre ont toujours 30 jours quelque soit l' année
Le nombre de jours de février est égal à 28. Sauf les années bissextiles.
Une année est bissextile lorsqu' elle est divisible par 4 et non par
100. Ou alors, elle est divisible par 400.
CORRECTION 15 :
1. public class Exercice15
2. {
3. public static void main (String [] args)
4. {
5. System.out.println("Vous voulez savoir le nombre de jours dans un mois ?");
6. System.out.println("1 = janvier 2 = Février 3 = Mars 4 = Avril 5 = Mai 6 = Juin");
7. System.out.println("7 = Juillet 8 = Août 9 = Septembre 10 = Octobre 11 = Novembre 12 = Décembre");
8. System.out.println();
9. System.out.print("Tapez le nombre correspondant au mois : " );
10. byte mois = Lire.entierByte();
11. System.out.println();
12. System.out.print("Maintenant, entrez l annee :");
13. int annee = Lire.entierInt();
14. System.out.println();
15.
16. int nombreDEjours = 0;
17.
18. switch(mois)
19. {
20. case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 :
21. nombreDEjours = 31;
22. break;
23.
24. case 4 : case 6 : case 9 : case 11 :
25. nombreDEjours = 30;
26. break;
27.
28. case 2:
29. if( (annee % 4 == 0) && (annee % 100 != 0) || (annee % 400 == 0 ) )
30. {
31. nombreDEjours = 29;
32. }
33. else
34. {
35. nombreDEjours = 28;
36. }
37. break;
38.
39. default :
40. System.out.println("Désolé : le nombre saisit ne correspond à aucun mois ");
41. System.exit(0);
42. }
43. System.out.println("Le nombre de jours dans l annee " + annee + " = " + nombreDEjours);
44. }
45. }
Explications :
L' utilisation de switch est déterminante ici. Cela nous évite des if et de multiples ou symbolisé par ||. Comme le switch n' accepte que les
variables de type int (ou des types dont la conversion peut être implicite, char, byte et short), le menu représenté par les lignes 6 et 7 était
donc un passage obligé. Ainsi, les nombres correpondants aux mois sont saisi puis affectée à la variable mois que j' ai choisi de type byte
parce qu' il n' y a que 12 mois. Economie de mémoire. byte va de -128 à +127. On prend le type int si d' emblée on ne sait pas le maximum que
prendra le nombre entier.
Quelque chose de nouveau. On peut utiliser plusieurs case pour une même conséquence. Donc par exemple, nombre de jours = 31 (ligne 20) pour les
cas où les numéros, 1, 3, 5, 7, 8, 10 et 12. Sachez que vous n' êtes pas obligés de mettre tous les case correspondant à une même conséquence
sur la même ligne. Vous auriez pu écrire :
case 1 : case 3 : case 5 :
case 7 : case 10 : case 12:
nombreDEjours = 31;
break;
Observons maintenant le case 2:
La conséquence d' un case peut très bien être une structure conditionnelle comme ici. Ce n' est pas anormal. L' important, c' est de mettre
cette structure entre le case et le break correspondant. L' instruction qui termine un case est toujours un break.
Une dernière chose : la ligne 42. System.exit() permet de sortir d' un programme. c' est la fonction (méthode) exit() de la classe System. On en
reparlera en expliquant le zéro dans ses parenthèses.
Sachez seulement que si vous voulez sortir d' un programme dans le cas où une erreur qui n' aboutit à aucune solution apparaît, vous utiliserez
cette méthode en écrivant exacvtement ceci : System.exit(0);
Pourquoi faut-il sortir de ce programme ? Parce que si vous saisissez un nombre ne correspondant à aucun mois, rien ne doit s' afficher.
En exécutant ce programme (après compilation bien sûr), vous comprendrez d' avantage.
EXERCICE 16 : Présence d' un caractère dans une chaine
Ecrire un programme qui demande à l' utilisateur de saisir un caractère. Puis le programme affiche le nombre de fois où l' on trouve ce caractère
dans une chaine pré-enregistrée.
CORRECTION 16 :
1. public class Exercice16
2. {
3. public static void main (String [] args)
4. {
5. String chaine = "Je suis en vacances, oubliez moi un peu.";
6. int nombreDEfois = 0;
7. System.out.print("Entrez un caractere : ");
8. char c = Lire.caractere();
9.
10. for(int i = 0; i < chaine.length(); i++)
11. {
12. if(chaine.charAt(i) == c)
13. nombreDEfois++;
14. }
15. System.out.println("On trouve " + c + ", " + nombreDEfois + " fois dans : " + "\" " +chaine + "\" ");
29. }
30. }
Compilez puis exécutez. Si vous entrez le caractère u, il sera affiché :
On trouve u, 4 fois dans : "Je suis en vacances, oubliez moi un peu."
Déclaration et affectation de la chaine pré-enregistrée ligne 5. Puis déclaration de la variable auquel sera affectée le nombre de fois, ligne 6.
Initialisation de cette variable à zéro. Puis la boucle parcours la chaine de la position zéro à la dernière position égale au nombre de
caractères (chaine.length() moins 1). Puis la méthodecharAt(i) (ligne 13) renvoie le caractère situé à la position i. Si ce caractère est le même
que le caractère saisi au clavier et affecté à la variable c (ligne 8), alors, incrémentation du nombre de fois. C' est ainsi qu' on trouve le
nombre de u dans la chaine.
Pas très compliqué n' est-ce pas ?
EXERCICE 17 : Somme des n premiers nombres entiers
Ecrire un programme qui demande à l' utilisateur de saisir un nombre entier n, positif et non nul. Puis le programme affiche la somme des n
premiers nombres entiers positifs non nuls. Exemple : on saisit 4 et le programme affiche 10. Car 1 + 2 + 3 + 4 = 10.
CORRECTION 17 :
1. public class Exercice17
2. {
3. public static void main (String [] args)
4. {
5. System.out.print("Saisissez un entier non nul : ");
6. int n, somme = 0;
7. n = Lire.entierInt();
8. for(int i = 1; i <= n; i++)
9. {
10.
11. somme += i;
12. }
13. System.out.println("la somme des " + n + " premiers entiers = " + somme );
14. }
15. }
Ligne 6. déclaration des variables n (nombre à saisir au clavier) et somme la somme à trouver initialisée à zéro. Puis on parcours la boucle de
1 à n. De 1 à n, on a bien les n premiers entiers positifs non nuls. Chacun de ces entiers représentée par i est ajoutée à la somme. De sorte
qu' en sortie de boucle, la somme est bien celle des n premiers entiers.
Testez différents nombres, vous verrez.
rappel : <= veut dire inférieur ou égal.
EXERCICE 18 : produit des n premiers nombres entiers
Ecrire un programme qui demande à l' utilisateur de saisir un nombre entier n positif et non nul. Puis le programme affiche le produit des n
premiers nombres entiers positifs non nuls. Exemple : on saisit 4 et le programme affiche 24. Car 1 * 2 * 3 * 4 = 24.
CORRECTION 19 :
1. public class Exercice18
2. {
3. public static void main (String [] args)
4. {
5. System.out.print("Saisissez un entier non nul : ");
6. int n, produit = 1;
7. n = Lire.entierInt();
8. for(int i = 1; i <= n; i++)
9. {
10.
11. produit += i;
12. }
13. System.out.println("la somme des " + n + " premiers entiers = " + produit );
14. }
15. }
Voici un de ces exemples sur lequel vous seriez tenté de changer le signe de l' addition en signe de la multiplication. Or, ce ne serait pas suffisant. L' initialisation de la variable produit (que vous auriez pris soin de remplacer par somme) ne doit pas être zéro. 0 est en effet un élément absorbant dans la multiplication. Il faut l' initialiser à 1 qui est un élément neutre pour la multiplication. De même que zéro l' était pour l' addition.
EXERCICE 19 : factoriel d' un entier positif non nul
Ecrire un programme qui demande à l' utilisateur de saisir un nombre entier positif non nul. Puis le programme affiche la valeur du factoriel de
ce nombre.
CORRECTION 19 :
1. public class Exercice19
2. {
3. public static void main (String [] args)
4. {
5. System.out.print("Saisissez un entier non nul : ");
6. int n, factoriel = 1;
7. n = Lire.entierInt();
8. for(int i = 1; i <= n; i++)
9. {
10.
11. produit += i;
12. }
13. System.out.println("le factoriel de " + n + " = " + factoriel);
14. }
15. }
Explications :
LE factoriel d' un nombre entier non nul n, c' est le produit des n premiers nombres entiers non nuls. 1 fois 2 fois 3 ..... fois n.
EXERCICE 20 : combinaison de p dans n
Ecrire un programme qui demande à l' utilisateur de saisir deux entiers positifs non nuls p et n. p étant bien sûr inférieur à n. Puis le programme affiche la combinaison de p dans n.
Rappel : combinaison de p dans n = factoriel de n divisé par (factoriel de p multiplié par factoriel de n moins p) = n!/p! * (n-p)!
CORRECTION 19 :
1. public class Exercice19
2. {
3. public static void main (String [] args)
4. {
5. int p, n; int factorielp = 1, factorieln = 1, factorieln_p = 1;
6. System.out.print("entrez un nombre entier non nul p : ");
7. p = Lire.entierInt();
8. System.out.print("entrez un nombre entier non nul n supérieur à p : ");
9. n = Lire.entierInt();
10. for(int i = 1; i <= n; i++)
11. {
12. factorielp += i;
13. }
14.
15. for(int i = 1; i <= n; i++)
16 {
17. factorieln += i;
18. }
19. int n_p = n - p;
20.
21. for(int i = 1; i <= n_p; i++)
22. {
23. factorieln_p += i;
24. }
25.
26. int combinaison = (factorieln) / (factoriel p * (factorieln_p);
27. return combinaison;
28. }
29. }
| précédent | sommaire | accueil | suivant |