Exercice java programme affiche un sapin décoré de guirlandes
Rédigé par GC Team, Publié le 15 Août 2010, Mise à jour le Lundi, 31 Août 2020 18:48
Participez au vote ☆☆☆☆☆★★★★★
But:
Ecrivez un programme permettant l'affichage d'un sapin décoré de guirlandes.
Thème:
algorithme
Il s'agit ici d'écrire un programme Sapin affichant un sapin décorés de guirlandes. Il n'est pas nécessaire pour cet exercice d'avoir recours à une approche orientée-objet. Vous pourrez vous contenter de la méthode main modularisée au moyen de méthodes auxiliaires.
Partie 1
Commencez par écrire une méthode permettant de stocker un triangle, dessiné avec un symbole donné, dans un tableau à deux dimensions. La hauteur du triangle (entre 8 et 35) ainsi que le symbole à utiliser seront demandés à l'utilisateur.
Le programme redemandera ces données à l'utilisateur tant qu'elles ne sont pas correctes.
Ecrivez ensuite une méthode affichant ce tableau.
Exemple d'exécution:
Quel symbole voulez-vous pour le triangle ? * Combien de lignes (de 8 a 35)? 8
Il s'agit maintenant de modifier la partie précédente pour permettre l'affichage d'un sapin décoré de guirlandes.
L'utilisateur devra introduire :
la hauteur souhaitée (toujours entre 8 et 35);
le symbole utilisé pour dessiner les épines du sapin (1 caractère);
le motif de guirlande à utiliser pour décorer le sapin (une chaîne entre 3 et 25 caractères). Les caractères utilisés pour les guirlandes devront différer de celui utilisé pour les épines.
Le programme redemandera les données nécessaires tant qu'elles ne sont pas correctes.
Les règles à utiliser pour la pose des guirlandes sont les suivantes :
les guirlandes seront posées de gauche à droite, une ligne sur 2 de l'arbre en commençant par la seconde ligne (depuis le haut);
des guirlandes seront placées autant de fois que possible sur une ligne, mais à chaque fois séparées par des épines. Le nombres d'épines séparant les guirlandes est choisi aléatoirement pour être soit 2 soit 3 (vous pourrez utiliser Math.random);
si la guirlande est trop longue pour être placée entièrement sur une ligne, elle sera "pliée" et continuera à décorer la ligne suivante de droite à gauche.
Voici un exemple d'exécution produit par cette partie du programme :
Quel symbole voulez-vous pour les épines du sapin? * Combien de lignes (de 8 a 35)? 8 Quelles guirlandes voulez-vous mettre (taille de 3 a 25 caractères et elles ne peuvent pas contenir le même caractère que celui utilisé pour les épines)? 0-0 * 0-0 ***** 0-0**0- ********0 0-0**0-0**0 ***********0- 0-0***0-0**0-0*
Pour faire plus réaliste, vous pourrez enfin ajouter un tronc à votre sapin. La taille du tronc devra être proportionnelle à celle du triangle.
Voici un exemple d'affichage (hauteur 10, avec 'x' pour les épines et "1234" pour les guirlandes) :
/* * Voici un codage possible de cet exercice * La code fourni permet de mettre en oeuvre les deux parties de l'exercice. * La première partie pourrait être réalisée sans passer par un tableau. * L'usage du tableau est surtout destiné à faciliter la programmation * de la seconde partie. */
importjava.util.Scanner;
publicclass Sapin {
/* * méthode remplissant le triangle, on construit à chaque ligne * le tableau de char de la dimension * correspondante (1 a la ligne 0, 3 à la ligne 1, etc) */ staticvoid remplirTriangle(char[][] triangle, char c){ int nbLigne = triangle.length; int nbColonne;
/* * Méthode ajoutant des guirlandes au triangle qui représente un sapin * sans decorations. */ staticvoid mettreGuirlande(char[][] sapinTriangle, String guirlande){ int nbLigne = sapinTriangle.length;
// La variable pointeurChar stocke l'indice du prochain caractère de // la guirlande à placer int pointeurChar =0; int longueurChaine = guirlande.length();
// Cette variable permet de différencier le cas où l'on pose les guirlandes // complètement, et le cas où l'on étend une guirlande sur les lignes // supplémentaires boolean completerGuirlande =false;
//les deux variables d'indice que l'on fera varier int i =0; int j =0;
while(i < nbLigne){ // on vérifie d'abord que nous sommes dans une ligne impaire // ou alors que l'on est en train de finir d'étendre une // guirlande sur les lignes suivantes if(i %2==1|| completerGuirlande){
// avec ces 2 instructions on remplace le caractère (i,j) // du sapin par le prochain caractère à placer // de la guirlande. pointeurChar donne la position // de ce caractère dans la guirlande. On incrémente ensuite // cette position en prenant le reste de la division // par rapport à la longueur de la guirlande //(quand on dépasse la position maximale possible, pointeurChar // reprend la valeur 0) sapinTriangle[i][j]= guirlande.charAt(pointeurChar); pointeurChar =(pointeurChar +1)% longueurChaine;
//ensuite il faut incrémenter les i et j en fonction de la //situation
if((j >= sapinTriangle[i].length-1&& pointeurChar !=0)|| completerGuirlande){ // Ce if gère le cas assez compliqué où il faut finir d'étendre la // guirlande sur la ligne d'en dessous. On utilise un boolean pour entrer // dans ce if jusqu'à ce que pointeurChar vaille 0; à ce moment on sait // que l'on a finit d'étendre la guirlande et on remet le boolean à faux. On // incrémente alors le j d'une quantité aléatoire. On n'incrémente pas la ligne car il // est tout à fait possible d'avoir couvert la deuxième ligne entièrement et // d'être revenu à une ligne impaire, dans ce cas on doit simplement continuer // avec la guirlande suivante
if(pointeurChar ==0){ completerGuirlande =false; j += random()+1; }else{ // sinon on gère les 3 cas possibles: // 1. on arrive pour la première fois ici et on change de ligne et on affecte j // au dernier index de la ligne d'en dessous // sinon, on est en train de compléter la guirlande (variable à vrai), dans ce cas : // 2. soit la ligne est paire, auquel cas on remplit de droite à gauche // 3. elle est impaire et on remplit de gauche à droite (cas de longues guirlandes où l'on // a recouvert toute la ligne supplémentaire et qu'on continue d'étendre sur la // suivante
if(!completerGuirlande){ completerGuirlande =true; ++i; if(i < nbLigne){ j = sapinTriangle[i].length-1; } }elseif(i %2==0){ --j; if(j <0){ ++i; j =0; } }else{ ++j; if(j >= sapinTriangle[i].length){ ++i; if(i < nbLigne){ j = sapinTriangle[i].length-1; } } } } }else{ // else de la condition // (j >= sapinTriangle[i].length - 1 && pointeurChar != 0) || completerGuirlande) //Dans ce cas on fait l'incrémentation normale de j, et éventuellement on ajoute //le nombre aléatoire pour laisser un peu d'espace if(pointeurChar ==0){ j += random(); } ++j; } //finalement on fait la vérification finale, qui incrémente la ligne et remet j à zéro si nécessaire if(i < nbLigne && j >= sapinTriangle[i].length&& pointeurChar ==0){ ++i; j =0; } }else{ //si la ligne n'était pas paire, on incrémente la ligne j =0; ++i; } } }
/* Méthode affichant le tableau sous forme triangulaire. */ staticvoid afficherTriangle(char[][] triangle){ int nbLigne = triangle.length; int nbColonne; int nbEspace;
/* Méthode ajoutant un tronc à l'arbre, elle choisit la hauteur et * la largeur en fonction du nombre de ligne du sapin. */ staticvoid afficherTronc(int nbLigne){ int largeur; int hauteur;
/* * Méthode choisissant aléatoirement entre 2 et 3 */
staticint random(){ int val =(int)(Math.random()*2);// 0 or 1 return(val+2);//return 2 or 3 }
/* * Programme principal * on demande les données nécessaires à l'utilisateur et vérifie que * les informations saisies soient correctes. * On appelle ensuite les méthodes dans le bon ordre pour construire puis * afficher le sapin */ publicstaticvoid main(String[] args){ Scanner sc =new Scanner(System.in); char[][] triangle; char symbole; int nbLigne; String guirlande;
System.out.print("Quel symbole voulez-vous pour les épines du sapin? "); symbole = sc.nextLine().charAt(0); do{ System.out.print("Combien de ligne (de 8 a 35)? "); nbLigne = sc.nextInt(); }while(nbLigne <8|| nbLigne >35); do{ System.out.print("Quelles guirlandes voulez-vous mettre "+ "(taille de 3 a 25 caractères et elles ne peuvent \n"+ "pas contenir le même caractère que celui utilisé pour les épines)? "); guirlande = sc.next(); }while(guirlande.length()<3|| guirlande.length()>25|| guirlande.contains(Character.toString(symbole)));
System.out.println();
//on initialise seulement le nombre de lignes que contiendra ce tableau (ligne), on pourra ensuite //choisir à chaque ligne le nombre d'éléments (colonne) triangle =newchar[nbLigne][]; remplirTriangle(triangle, symbole); mettreGuirlande(triangle, guirlande); afficherTriangle(triangle); afficherTronc(triangle.length);
/* Note pour la partie 1: il suffit d'invoquer les méthodes suivantes * (après la saisie des données utiles) : * * remplirTriangle(triangle, symbole); * afficherTriangle(triangle); */ }