| précédent | sommaire | accueil | suivant |
PROJET LOTO :
Le jeu LOTO de la française des jeux (http://www.fdjeux.com/) consiste à trier 6 numéros au hasard pris parmi 49 allant de 1 à 49. Ce sont
des nombres entiers. Ces 6 numéros sont tous différents. Puis il y tirage d' un 7ème numéro appelé complémentaire.
Chaque joueur joue coche 6 numéros d' une grille en loto simple. Il peut jouer autant de grilles qu' il veut. Puis 7 à 10 numéros d' une grille
en loto multiple.
Dans un premier temps, nous allons nous interesser au loto simple avec une seule grille.
Ecrire un programme qui demande au joueur de saisir au clavier 6 nombres entiers allant de 1 à 49. Puis le programme effectue un tirage au hasard
de 6 numéros. PAS DE 7ème NUMERO POUR L' INSTANT. Puis le programme affiche ces 6 numéros dans l' ordre de sortie. Puis les affiche dans l' ordre
croissant. Puis le programme affiche les numéros du jouer par ordre croissant. Puis le programme informe le joueur le fait qu' il ait ou non
trouvé de bons numéros.
Par exemple selon les cas,
Vous avez trouvé zéro bons numéros : vous avez donc perdu
Vous avez trouvé 1 seul bon numéro : vous aveez donc perdu
Vous avez trouvé 2 bons numéros : vous avez donc perdu
Vous avez trouvé 3 bons numéros : vous avez donc gagné
Vous avez trouvé 4 bons numéros : vous avez donc gagné
Vous avez trouvé 5 bons numéros : vous avez donc gagné
Vous avez trouvé 6 bons numéros : vous avez donc gagné
N' oubliez pas d' afficher les numéros trouvés.
Vous ne pouvez pas écrire une méthode pouvant faire tout ceci. C' est évident. Alors, j' ai mis du temps, mais je suis arrivé à résoudre le problème en écrivant un certain nombre de fonctions ou méthodes.
*********************
exercice 1 : afficher les valeurs d' un tableau
Ecrire une méthode qui, étant donné un tableau d' entiers, affiche les valeurs de ce tableau sur une même ligne.
CORRECTION 1 :
1. public static void afficheTableau(int [] tab)
2. {
3. for(int i = 0; i < tab.length; i++)
4. {
5. System.out.print(tab[i] + " - ");
6. }
7. }
Facile, car déjà vu n' est-ce pas ?
*********************
EXERCICE 2 : présence d' une valeur donné dans un tableau
Ecrire une méthode qui, étant donné un tableau d' entiers et un nombre entiers, teste la présence de ce nombre dans ce tableau
CORRECTION 2 :
1. public static boolean nombreDansTableau(int n, int [] tab)
2. {
3. boolean verite = false;
4. for( int i = 0; i < tab.length; i++)
5. {
6. if(tab[i] == n)
7. {
8. verite = true;
9. break;
10. }
11. }
12. return verite;
13. }
Facile, car déjà vu aussi n' est-ce pas ?
*********************
EXERCICE 3 : nombre de fois une valeur donné dans un tableau
Ecrire une méthode qui, étant donné un tableau d' entiers et un nombre entiers, retourne le nombre de fois où on trouve ce nombre entier dans ce
tableau.
CORRECTION 3 :
1. public static int nombreDeFoisValeurDansTableau(int [] tab, int n)
2. {
3. int nombreDeFois = 0;
4. for( int i = 0; i < tab.length; i++)
5. {
6. if(tab[i] == n)
7. {
8. verite = true;
9. nombreDeFois++;
10. }
11. }
12. return nombre;
13. }
Ah ! pas encore vu. Explication :
Puisque la méthode doit retourner un nombre entier (nombre de fois ), alors, elle est de type int. D' où le mot clé int juste avant le nom de la
méthode. Puis dans la définition de la méthode, on crée alors catte variable de type int sui sera retournée : ligne 3. On initialise cette
variable à zéro. Puis on parcours le tableau (ligne 4). Si on trouve un élément du tableau (tab[i] ) dont la valeur est celle du nombre entier n,
alors, la variable nombreDeFois est incrémentée de 1. Ici, on est bien obligé de parcours le tableau de bout en bout. Puis on retourne la variable
nombreDeFois qui contient le nombre de fois où l' on trouve la valeur de n dans le tableau.
EXERCICE 4 : nombre d' éléments intersection de 2 tableaux
Ecrire une méthode qui, étant donné 2 tableaux de nombres entiers, renvoie le nombres d' éléments du 1er tableau dont la valeur est égale
à celle d' au moins un élément du 2ème tableautableau.
CORRECTION 4 :
1. public static int nombEltsTab1DansTab2(int [] tab1, int [] tab2)
2. {
3. int nombElts = 0;
4. for(int i = 0; i < tab1.length; i++)
5. {
6. if(nombreDansTableau(tab1[i], tab2))
7. {
8. nombElts++;
9. }
10. }
11. return nombElts;
12. }
La méthode doit retourner le nombre d' éléments du premier tableau dont la valeur est celle d' au moins une élément qu' on trouve dans le
deuxième tableau. La méthode est donc de type int.
Les arguments sont naturellement les deux tableaux en question. Puis on créé la variable contenant ce nombre de valeurs du premier dans le 2ème.
On parcours le tableau 1, Si on trouve un élément du premier dans le deuxième, alors, on incrémente nombElts.
Mais que signifie ce code dans les parenthèses de if (ligne 6) ? C' est très simple. C' est la méthode nombreDansTableau() que nous avons définie
exercice 2. Nous l' avons utilisé ici. Cette méthode requiert 2 arguments. Le premier est le nombre entier et le deuxième est la tableau d' entiers.
C' est de cette façon que nous l' avons utilisée ici. tab1[i] représente le nombre entier (valeur de l' élément du premier tableau en position i)
et tab2 représente le deuxième tableau.
Vous voyez, on utilise une méthode dans une autre méthode qui n' est pas forcément la méthode main(). Et nous verrons souvent une méthode utiliséee
dans une autre méthode qui, elle aussi est utilisée dans une autre méthode, etc...
EXERCICE 5 : Intersection de 2 tableaux
Ecrire une fonction qui, étant donné 2 tableaux de nombres entiers, renvoie un tableau dont les valeurs sont commune aux 2 premiers tableaux.
Ex : premier tableau : 2, 5, 9, 10, 3 et deuxième tableau : 1, 3, 5, 7 troisième tableau : 2, 3, 5
CORRECTION 5 :
1. public static int [] tabIntertabs(int [] tablo1, int [] tablo2)
2. {
3. int n = nombEltsTab1DansTab2(tablo1, tablo2);
4. int [] tab = new int [n];
5. int j = 0;
6. for(int i = 0; i < tablo1.length; i++)
7. {
8. if( nombreDansTableau(tablo1[i], tablo2))
9. {
10. tab[j] = tab1[i];
11. j++;
12. }
13. }
14. return tab;
15. }
Ici, on utilise 2 méthodes déjà utilisées : nombEltsTab1DansTab2() et nombreDansTableau().
Ligne 3 : je déclare une variable dont la valeur est le nombre d' éléments communs aux deux tableaux. J' utilise pour cela la méthode (ligne 3)
nombEltsTab1DansTab2() qui justement retourne le nombre d' éléments communs à 2 tableaux. Cette variable n, sera forcément la taille du tableau
contenant les valeurs communes aux deux tableaux. Ce que je fais ligne 4. L' astuce c' est de parcourir le premier tableau (ligne 6), puis de
dire que si l' élément en position i se trouve aussi dans le deuxième tablo (ligne 8), alors, mettre cette valeur dans le tableau intersection.
J' ai défini une variable ligne 5 que j' ai initialisée à zéro. Je l' ai définie hors de la boucle parce quu tous les éléments de tablo ne font
pas forcément partie de l' intersection. Ainsi, la valeur de j évolue(j++) seulement si on trouve une valeur commune à tablo1 et tablo2 qu' on
met dans tab (tableau intersection). En réfléchissant un tant soit peu, vous comprendrez qu' il est évident que j ne doit pas être incrémentée
en même temps que i. D' où sa définition hors boucle.
Une dernière chose, le type d' une méthode étant le type de la valeur fournie ( retouréne, renvoyée), ici, la méthode renvoie un tableau de
nombres entiers. Le type tableau de nombres entiers, c' est bien int [], d' où le int [] devant le nom de la méthode tabIntertabs().
EXERCICE 6 : Détection d' une valeur d' un tableau supérieure à un nombre donné
Ecrire une méthode qui, étant donné un nombre entier et un tableau de nombres entiers, teste la présence dans le tableau, d' au moins un
élément dont la valeur est supérieur au nombre entier.
CORRECTION 6 :
1. public static boolean eltTabSupNomb(int n, int [] tab)
2. {
3. boolean verite = false;
4. for(int i = 0; i < tab.length; i++)
5. {
6. if(tab[i] > n)
7. {
8. verite = true;
9. break;
10. }
11. }
12. return verite;
13. }
Méthode booléenne, c' est évident non ? On parcours le tableau. SI on trouve un seul élément dont la valeur est supérieure à n, verite = true. Puis on sort aussitôt de la boucle. Pas la peine de parcourir le reste du tableau. Sinon, verite reste à false comme initialisée. Puis on retourne verite.
**********
EXERCICE 7 : Détection d' une valeur d' un tableau inférieure à un nombre donné
Ecrire une méthode qui, étant donné un nombre entier et un tableau de nombres entiers, teste la présence dans le tableau, d' au moins un
élément dont la valeur est inférieure au nombre entier.
CORRECTION 7 :
1. public static boolean eltTabInfNomb(int n, int [] tab)
2. {
3. boolean verite = false;
4. for(int i = 0; i < tab.length; i++)
5. {
6. if(tab[i] < n)
7. {
8. verite = true;
9. break;
10. }
11. }
12. return verite;
13. }
Même raisonnement que dans le 6. Mais on remplace > par <. Car cette fois, on cherche un élément du tableau inférieur à un entier donné.
**********
EXERCICE 8 : S' assurer que les valeurs d' un tableau sont bornées.
Ecrire une méthode qui, étant donné un intervalle de nombres entiers et un tableau de nombres entiers, vérifie que chaque valeur de ce tableau
appartient à cet intervalle.
CORRECTION 8 :
1. public static boolean tabBornes(int n1, int n2, int [] tab)
2. {
3. if(!eltTabSupNomb(n2, tab) && !eltTabInfNomb(n1, tab))
4. {
5. return true;
6. }
7. else
8. {
9. return false;
10. }
11. }
Ici, on ne se casse pas trop la tête. Cette méthode utilise les 2 méthodes précédentes. En effet, si aucun élément du tableau n' est supérieure à une valeur donnée, et en même temps, aucune valeur du tableau n' est inférieure à une autre valeur données, alors, les tableau est forcément borné par ces deux valeurs données. Sachez qu' ici, n2 est forcément supérieur à n1. Je rappelle que le point d' exclamation signifie la négation d' une condition booléenne. Ligne veut dire alors : Si aucun élément de tab n' est supérieur à n2 et si aucun élément de tab n' est inférieur à n1, alors forcément, chaque valeur du tableau appartient à l' intervalle bornée par n1 et n2. Dans le cas contraire (else), la condition booléenne est fausse évidement.
**********
EXERCICE 9 : Créer un tableau d' entiers dont les valeurs sont bornées
Ecrire une fonction qui, étant donné un nombre entier n positif et un intervalle de nombres entiers n1 et n2 positifs aussi, avec n2 > n1,
renvoie un tableau de n nombres entiers dont les valeurs sont prises au hasard dans l' intervalle n1, n2 (inclus).
CORRECTION 9 :
1. public static int [] tabHasard(int n, int n1, int n2)
2. {
3. int [] tab = new int [n];
4. for(int i = 0; i < n; i++)
5. {
6. tab[i] = (int) ( (Math.random() * (n2 - n1)) + n1);
7. }
8. return tab;
9. }
La fonction Math.random(), comme vous le savez, permet de générer un nombre de type double, pris au hasard entre 0 et 1. 0 inclu et 1 exclu. Donc
dans l intervalle : [0, 1[.
Pour générer un nombre de type double se trouvant dans l' intervalle [0, 5[, on fait Math.random() * 5.
Pour générer un nombre de type double se trouvant dans l' intervalle [0, 10[, on fait Math.random() * 10.
Pour générer un nombre de type double se trouvant dans l' intervalle [1, 10[, on fait (Math.random() * 9) + 1. En effet, (Math.random() * 9)
génère un nombre reel se trouvant dans [0, 9[. En ajoutant 1 à cet intervalle, on obtient bien l' intervalle [1, 10[ (0 + 1 = 1 et 9 + 1 = 10 )
Pour générer un nombre de type double se trouvant dans l' intervalle [-2, 10[, on fait (Math.random() * 12) - 2. En effet, (Math.random() * 12)
génère un nombre reel se trouvant dans [0, 12[. En ajoutant -2 à cet intervalle, on obtient bien l' intervalle [-2, 10[
Pour générer un nombre de type double se trouvant dans l' intervalle [n1, n2[, on fait (Math.random() * (n2 - n1)) - n1. En effet,
(Math.random() * n1) génère un nombre réel se trouvant dans [0, n2 -n1[ En ajoutant à cet intervalle la valeur n1,
, on obtient bien l' intervalle [n1, n2[. Si vous ne pigez pas, tester avec des exmples. ça marche comme sur des roulettes.
Ceci étant dit, La boucle permet d' affecter chaque variable du tableau avec forcément une valeur de l' intervalle n1, n2. Puis on retourne le
tableau.
EXERCICE 10 : S' assurer de l' unicité des valeurs d' un tableau d' entiers
Ecrire une fonction qui, étant donné un tableau, vérifie que chaque valeur d' un élément du tableau est unique.
CORRECTION 10 :
1. public static boolean eltsTabTousDiff(int [] tab)
2. {
3. boolean verite = true;
4. for(int i = 0; i < tab.length; i++)
5. {
6. if(nombreDeFoisValeurDansTableau(tab[i], tab) != 1)
7. {
8. verite = false;
9. break;
10. }
11.
12. }
13. return verite;
14. }
Pour savoir si un valeur du tableau est unique dans ce tableau. On parcours évidement le tableau. Puis on voit si le nombre de fois où chaque valeur se trouve dans le tableau estseulement égal à 1. Dans ce cas, la réponse à l' affirmation "les valeurs sont tous uniques" est vraie. Nous utilisaons pour cela une méthode déjà définie (exercice 3). En parcourant le tableau (ligne 4), si on trouve un seul élément du tableau dont la valeur se trouve plus d' une fois dans le tableau( ligne 6), alors, la variable booléenne qu' on retourne est false. Puis on sort aussitôt de la boucle. Puisqu' il est inutile de chercher d' avantage. C' est pourquoi ici, contrairement aux exos précédent de méthode booléenne, j' ai initialisée verite à true. Donc, l' initialisation d' une variable booléenne n' est pas forcément false. Il faut toujours s' assurer que la méthode créée permet d' être efficace. Rapide en l' occurence.
**********
EXERCICE 11 : S' assurer que les valeurs d' un tableau sont bornées et qu' elles sont uniques.
Ré-écrire la méthode de l' exercice 9 :
Ecrire une méthode qui, étant donné un nombre entier n positif et un intervalle de nombres entiers n1 et n2 positifs aussi, avec n2 > n1,
renvoie un tableau de n nombres entiers dont les valeurs sont prises au hasard dans l' intervalle n1, n2 (inclus).
Mais cette fois, une condition supplémentaire s' ajoute : chaque valeur de ce tableau est unique.
CORRECTION 11
1. public static int [] tabHasardUniq(int n, int n1, int n2)
2. {
3. int [] tab = new int [n];
4. do
5. {
6. for(int i = 0; i < n; i++)
7. {
8. tab[i] = (int) ( (Math.random() * (n2 - n1)) + n1);
9. }
10. }
11. while(!eltsTabTousDiff(tab));
12.
13. return tab;
14. }
Remarquez, c' est la même boucle for que dans l' exo 9. Mais on l' a imbriquée dans une boucle do while. On continue de générer un tableau de nombres entiers, tant que tous les valeurs du tableaux ne sont pas tous différents. Sur la ligne 11, on utilise la méthode 10 qui permet de vérifier si tous les éléments d' un tableau sont différents. Et tant que (while) ce n' est pas le cas, le point d' exclamation devant l' appel de cette méthode (!eltsTabTousDiff(tab)) illustre le fait que ce ne soit pas le cas, alors, on génère un nouveau tableau. Et la boucle s' arrêtera seulement lorsque le tabeau généré aura toutes ses valeurs différents les unes des autres.
**********
EXERCICE 12 : Ranger les valeurs d' un tableau d' entiers par ordre croissant
Ecrire une fonction qui, étant donné un tableau de nombres entiers, renvoie le même tableau. Même cette fois, les valeurs du tableau sont
classées par ordre croissant.
Ah tiens, on a déjà fait ça non ? Voir exercice 7 de cette page exos sur les tableaux . Je vous avais promis
de traiter ce problème différement. C' est ce qu' on va faire ici.
CORRECTION 12
1. public static int [] tabOrdCrois(int [] tab)
2. {
3. boolean verite;
4. do
5. {
6. verite = false;
7. for(int i = 0; i < (tab.length - 1); i++)
8. {
9. if(tab[i] > tab[i+1])
10. {
11. int tampon = tab[i];
12. tab[i] = tab[i+1];
13. tab[i+1] = tampon;
14. verite = true;
15. }
16. }
17. }
18. while(verite);
19. return tab;
20. }
Ici, nous n' avons pas utilisé deux boucles for. Regardez l' exo 7 de exos sur les tableaux et comparez. Ici,
de la ligne 7 à la ligne 16, on fait en sorte que si deux valeurs consécutives sont telle que le précédent est supérieur au suivant, alors, il
y a permutation de valeurs. On englobe ceci dans un boucle do...while pour rendre la méthode plus efficace. En effet, si on parcours le tableau
à un moment donné et que les nombres sont déjà rangés par ordre croissant, pas la peine de continuer à le parcourir. La variable booléenne
verite devient true lorsque on n' a pas trouvé une valeur précédent supérieure à une valeur suivante. Dans ce cas, la boucle do...while s' arrête.
Et while(verite) est équivalent à while(verite == true). De même, while(verite == false) correspond à while(!verite). Le fameux point d'
exclamation permet la négation d' une condition booléenne.
Si vous n' avez pas compris du premier coup, relisez, réfléchissez un peu, et vous comprendrez.
Maintenant, nous allons utiliser ces douze méthodes pour créer un programme qui simule le jeu LOTO en tenant compte que le joueur joue une seule
grille de 6 numéros et que le numéro complémentaire n' existe pas.
Pour commencer, mettre les douze méthodes dans une classe contenant dont le programme simule le jeu Loto. Nous allons l' appeler Loto justement.
Nous devons aussi mettre les commentaires afin que quiconque consulte notre programme comprennent à quoi servent ces méthodes.
Dans la méthode main(), vous mettrez le code pour que le programme simule le jeu LOTO. Ou alors, vous regarez la correction sur cette page.
M. JOURDAIN est un personnage célèbre du roman de MOLIERE intitulé : le bourgeois gentilhomme. Quand on lit ce bouquin, on se souvient forcément
de sa fameuse prose : Belle Marquise, vos beaux yeux me font mourir d'amour.
Et ses variantes :
D'amour mourir me font, belle Marquise, vos beaux yeux.
ou
Vos yeux beaux d'amour me font, belle Marquise, mourir.
ou
Mourir vos beaux yeux, belle Marquise, d'amour me font.
ou
Me font vos yeux beaux mourir, belle Marquise, d'amour.
Le but de se projet est d' écrire un programme qui demande à l' utilisateur de saisir au clavier une phrase. Puis le programme affiche cette
phrase en changeant l' ordre des mots de façon hasardeuse. Après avoir écrit le programme, saisissez comme exemple, la prose de M. JOURDAIN.
Pour y arriver, nous allons devoir écrire un certain nombre de méthodes.
exercice 1 : remplacez multi-espaces en mono-espaces
Ecrire une méthode qui, étant donné une chaine de caractères, renvoie la même chaine. Mais à chaque
CORRECTION 1 :
Le triangle de pascal, tous les matheux le connaissent. Sans vous le définir, voici les 7 premières lignes de ce triangle.
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
Il y a une logique dans l' ordre de succession des lignes et des colonnes. A vous de le trouver. C' est après avoir trouvé cette logique que vous
pourrez écrire un programme qui demande à l' utilisateur d' entrer un nombre n. Puis le programme affiche les n premières lignes de ce triangle.
Vous ne pouvez pas écrire une méthode pouvant faire tout ceci. C' est évident. Alors, j' ai mis du temps, mais je suis arrivé à résoudre le problème en écrivant un certain nombre de fonctions ou méthodes.
*********************
EXERCICES 1 : Calcul du factoriel d' un entier
Ecrire une méthode qui, étant donné un nombre entier positif, rend le factoriel de ce nombre.
CORRECTION 1
1. public static int factoriel(int n)
2. {
3. int produit = 1;
4. if(n != 0)
5. {
6. for(int i = n; i > 0; i--)
7. {
8. produit *= i;
9. }
10. }
11. return produit;
12. }
Le factoriel de 0 et celui de 1 est toujours égal à 1
Sinon,
le factoriel d' un nombre est le produit des tous les nombres qui vont de ce nombre à 1. 4! = 4 fois 3 fois 2 fois 1 = 24
Je déclare alors une variable appelée produit (ligne 3) aue j' initialise à 1. 1 est l' élément neutre pour la multiplication. Puis je parcours
tous les nombres de n à 1. Et je dis que la nouvelle valeur de produit = l ancienne valeur de produit multipliée par la nouvelle valeur de i.
rappel : produit *= i; correspond à produit = produit * i;
Puis je retourne produit (ligne 8).
Il existe une autre façon de faire. La méthode utilisée est dite récursive. Une méthode récursive est une méthode qui fait appel à elle même.
Voyez plutôt !
CORRECTION 1BIS
1. public static int factoriel(int n)
2. {
3. if(n == 0 || n == 1)
4. {
5. return 1;
6. }
7. else
8. {
9. return (n * factoriel(n - 1));
10. }
11. }
La récursivité d' une méthode consiste à utiliser une méthode à l 'intérieur de la méthode.
Si n = 0 ou n = 1, factoriel n = 1. d' où lignes 3 et 5.
Sinon, factoriel n = n multiplié par factoriel de n-1.
EXERCICES 2 : Nombre de combinaisons
Ecrire une méthode qui, étant donné deux nombres entiers positif p et n, avec p inférieur à n, rend le nombre de combinaisons de p dans n.
CORRECTION 2
1. public static int combinaisons(int p, int n)
2. {
3. return ( factoriel(n) / (factoriel(p) * factoriel(n - p) ) );
4. }
Pas trop de commentaires ici. Nombre de combinaisons de p dans n = factoriel n divisé par factoriel p multiplié par factoriel de n moins p.
*************
EXERCICES 3 : ligne du triangle de Pascal
Ecrire une méthode qui, étant donné un nombre entier positif non nul n, renvoie un tableau dont les valeurs sont par odre celles de la nième
ligne du triangle de pascal
CORRECTION 3
1. public static int [] ligneTrianglePascal(int n)
2. {
3. int [] tab = new int [n];
4. tab[0] = 1; tab[n-1] = 1;
5. for(int i = 1; i < (n - 1); i++)
6. {
7. tab[i] = combinaisons(i, n-1);
8. }
9. return tab;
10. }
Dans le triangle de Pascal, la ligne numéro 1 possède 1 seul élément. La ligne numéro 2 possède 2 éléments. La ligne 3, 3 éléments. Ainsi de suite. Donc, la nième ligne de Pascal contient n éléments. C' est pourquoi le tableau à renvoyer possède n éléments. Ligne 3 du code. A la ligne 4 du code je dis que le premier élément a pour valeur zéro. Le dernier élément aussi. Qualque soit la ligne su triangle, les première et derniere valeurs sont 1 et 1. Puis je parcours tous les autres éléments de la ligne. Leur valeur est toujours le nombre de combinaisons de de leur position dans le nombre de valeurs que possède la ligne.
*************
EXERCICES 4 : Afficher Tableau
Méthode permettant d' afficher les valeurs d' un tableau d' entiers sur la même ligne. Séparer les valeurs par une tabulation.
CORRECTION 4
1. public static void afficherTableau(int [] tab)
2. {
3. for( int i = 0; i < tab.length; i++)
4. {
5. System.out.print(tab[i] + "\t");
6. }
7. }
Déjà vu. Sauf peut-être la tabulation qui est à reviser. "\t" = tabulation.
*************
EXERCICES 5 : Afficher les n premières lignes su triangle Pascal
Grâce à ces méthodes, on peut écrire la programme qui demande à l utilisateur d' entrer un nombre positif non nul. Puis le programme affiche
les n premières lignes du triangle de Pascal
Correction projet Triangle de Pascal
| précédent | sommaire | accueil | suivant |