Dessin avec boucle for

Version imprimable

Bonjour,
ce scripte dessine cette figure

*
**
***
****
*****
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class Projet3 { public static void main(String[] args) { int i; int j; for (i = 1; i <= 5; i++) { for (j = 0; j < i; j++) { System.out.printf("*"); } System.out.printf("\n"); } } }
ce que voudrais en partant du script que je post c'est obtenir ceci

*
**
***
****
*****
****
***
**
*

merci

09/07/2015, 16h58
joel.drigo

Salut,

Tu vois que la deuxième forme est consitué des lignes de la première forme, suivies des lignes de la première forme, dans le sens inverse (sauf la plus longue) : ça devrait t'orienter sur la façon de le faire. Reprendre la même boucle, mais faire varier l'indice dans l'autre sens... à un décalage près pour ne pas avoir la dernière ligne.

Voir par ailleurs Cette discussion qui traite de problèmes similaires.

merci
j'ai fait ceci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Projet3 {
	public static void main(String[] args) {
 
		int indice =5;
		int i;
		int j;
 
		for (i = 1; i <= indice; i++) {
 
			for (j = 0; j < i; j++) {
				/* affiche une etoile */
				System.out.printf("*");
 
			}
 
			System.out.printf("\n");
 
		}
 
		for (i = indice-1; i > 0; i--) {
 
			for (j = 0; j < i; j++) {
				System.out.printf("*");
			}
 
			System.out.printf("\n");
 
		}
 
	}
}

y'a t'il une façon d’écrire ce script de manière plus optimisé ? ( tout en restant dans l'utilisation de boucles for imbriquées )

Il y a une petite erreur dans ton code : tu doubles la ligne la plus grande :
*
**
***
****
*****
*****
****
***
**
*
Il ne faut pas refaire la boucle pour i = 5 pour la seconde partie, donc le code est :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public static void main(String[] args) { int i; int j; for (i = 1; i <= 5; i++) { for (j = 0; j < i; j++) { System.out.printf("*"); } System.out.printf("\n"); } for (i = 4; i > 0; i--) { for (j = 0; j < i; j++) { System.out.printf("*"); } System.out.printf("\n"); } }
Après l'optimer, difficile. Je ne vois pas trop quoi optimiser. On ne risque pas de gagner des masses de toutes manières.

La boucle for (i = 1; i <= 5; i++) pourrait s'écrire for (i = 0; i <6; i++) pour gagner un pouillème peut-être, mais perdre la logique dans la borne.

Maintenant, je ne vois pas d'autres solutions en conservant les for imbriqués

Sinon, on pourrait stocker les lignes dans un stringbuilder, mais faudrait tester, je ne suis pas sûr que ça soit plus rapide (occupant plus de mémoire c'est sûr) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 StringBuilder sb = new StringBuilder(5); for (int i = 0; i < 5; i++) { sb.append("*"); System.out.println(sb); } for (int i = 0; i < 4; i++) { sb.delete(sb.length()-1,sb.length()); System.out.println(sb); }
On peut le faire en récursif, mais ça ne sera pas plus optimisé (rien que la consommation liée à la pile sera de la perte). Après, il y a peut être une astuce qu'à laquelle je ne pense pas, mais tout le reste n'est que beaucoup d'effort pour optimiser quelque chose qui n'a pas vraiment besoin de l'être pour gagner quelques nanosecondes au mieux...

La où on peut probablement gagner c'est :
Code:

1 2 System.out.println("*\n**\n***\n****\n*****\n****\n***\n**\n*\n");
mais il n'y a pas de boucles ;)

Tu peux aussi le faire en récursif, AVEC des boucles (pas imbriquées)!

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
	public static void main(String args[]) {
		displayStar(1);
	}
 
	public static void displayStar(int index) {
		System.out.println("");
		for (int i = 0; i < index; i++) {
			System.out.print("*");
		}
		if (index < 5) {
			displayStar(index+1);
		}
		System.out.println("");
		for (int i = 0; i < index - 1; i++) {
			System.out.print("*");
		}
 
	}

Citation:

Envoyé par eulbobo

Tu peux aussi le faire en récursif, AVEC des boucles (pas imbriquées)!

Avec if ( index>1 ) System.out.println(); en première ligne pour ne pas avoir de ligne vide supplémentaire en première ligne.

On peut aussi faire ça si on veut s'amuser (à avoir un code dont il est difficile de savoir ce qu'il fait sans l'exécuter ;)):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 public static void main(String[] args) { final StringBuilder s1 = new StringBuilder(4); s1.append("*"); final String s2 = "\n*"; System.out.print(s1); System.out.print(s2); for(int i=0; i<3; i++) { System.out.print(s1); System.out.print(s2); s1.append("*"); } System.out.print(s1); System.out.print(s2); for(int i=0; i<3; i++) { s1.setLength(s1.length()-1); System.out.print(s1); System.out.print(s2); } }

09/07/2015, 18h48
serna

Citation:

Il y a une petite erreur dans ton code : tu doubles la ligne la plus grande

c'est vrai mais entretemps j'avais corrigé le code

Code:

for (i = indice-1; i > 0; i--)

merci pour vos codes ça me permettra de les étudier pour avancer , même si je n'ai pas encore aborder certaines notions
( par exemple l'utilisation de la classe StringBuilder , la méthode append de la classe StringBuffer ou le recursif )
là je m'entraine sur les boucle for

encore merci
10/07/2015, 02h02
bouye

Sauf que non, la meilleur optimisation est le paramétrage de l'indice de départ, de l'indice d’arrivée et de l’incrément, ce qui permet d’écrire une seule et unique boucle pour dessiner les deux cas de figure ;)
10/07/2015, 10h07
eulbobo

1 pièce(s) jointe(s)

Citation:

Envoyé par joel.drigo

Avec if ( index>1 ) System.out.println(); en première ligne pour ne pas avoir de ligne vide supplémentaire en première ligne.

J'avoue, j'ai été feignant sur le coup ^^

Citation:

On peut aussi faire ça si on veut s'amuser (à avoir un code dont il est difficile de savoir ce qu'il fait sans l'exécuter ;)):

Pièce jointe 182753
11/07/2015, 00h13
francky74

Bonjour,

Je viens de voir ce petit programme qui fait un triangle .... cela me rapelle qu'en cours nous avons fait de même et je pense que cela doit être finalement un standard de l'apprentissage :)

Donc dans l'esprit de rajouter une difficulté pour t'aider à progresser, comment ferais-tu le même triangle mais en dessinant les bords avec des caractères différent des caractères du centre du triangle (c'était la suite de l'exercice que le prof nous a donné ...)

:pingoin2:
11/07/2015, 00h51
serna

merci francky74 , je vais essayé de faire ton exo (il va me falloir un peu de temps !)..perso je me forme tout seul avec des bouquins et des tutoriels sur le net.

bon...ça chauffe dur dans le ciboulot et je n'ai pas trouvé. je ne suis pas assez avancé en java.
j'ai pensé à utiliser un tableau et faire des conditions mais je n'ai pas trouvé ( pas encore !)

j'ai trouvé un script sur le net ( me rappelle plus le site ) ou il donne un script qui dessine un triangle (inversé) avec au bord un caractère et à l’intérieur du triangle un autre caractère ( en fait c’était des espaces à l’intérieur et à l’extérieur du triangle)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public class DessinTriangle { static int iteration = 0; public static void Triangle(int n) { int nombreEspaceExterne = n - iteration; int nombreTiret = iteration > 0 ? iteration * 2 - 1 : 0; String espace = new String(new char[nombreEspaceExterne]).replace("\0", " "); String tiret = new String(new char[nombreTiret]).replace("\0", "-"); String etoile = "*"; String ligne = iteration == n - 1 ? espace + new String(new char[n * 2 - 1]).replace("\0", "*") + espace : iteration > 0 ? espace + etoile + tiret + etoile + espace : espace + etoile + espace; iteration++; if (iteration < n) { Triangle(n); } System.out.println(ligne); } public static void main(String[] args) { Triangle(7); } }
si quelqu'un trouve comment faire ça avec des tableaux ça serait super

14/07/2015, 19h30
serna

pas fais gaffe mais dans le script plus haut il y'a des tableaux ...

Code:

new String(new char[nombreEspaceExterne])

Ce code est affreux.

Premièrement le devoir de clarté doit remporté sur la concision de code :

Les String ligne = iteration == n - 1 ? espace + new String(new char[n * 2 - 1]).replace("\0", "*") + espace : iteration > 0 ? espace + etoile + tiret + etoile + espace : espace + etoile + espace;sont peut-être valables dans un concours du programme tenant sur le moins de lignes (cf le 2 lignes de hebdogiciel), mais le meilleure moyen d'apprendre à faire ce qui par la suite est une plaie pour la maintenance du code.

Ensuite, on a le droit (voire le devoir) de faire des méthodes :
String espace = new String(new char[nombreEspaceExterne]).replace("\0", " ");Ici, la volonté est probablement d'écrire un code concis (dans le même esprit abscons que le point ci-avant), tout en faisant une accrobatie absurde (le replace).
Une méthode :

Code:

1
2
3
4
5
public static String creer(char c, int nombre) {
char[] array = new char[nombre];
Arrays.fill(array, c);
return new String(array);
}

sera plus clair et accessoirement plus efficace.

La variable iteration déclarée en variable de classe est une hérésie. Non seulement, la méthode Triangle ne peut être appelée qu'une seule fois, mais ne pourra pas être utilisée concuremment dans plusieurs threads. Dans le contexte, ça n'a sûrement aucune utilité, mais dans le cas général, c'est une structure qu'il vaut mieux effacer de sa mémoire, pour éliminer le risque de le faire dans un contexte plus général, où les dysfonctionnements conséquents seront plus difficiles à déboguer.

On peut faire comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
public static void Triangle(int n) {
    	Triangle(n, 0);
    }
    private static void Triangle(int n, int iteration) {
       /*...*/
       iteration++;
       if (iteration < n) {
           Triangle(n, iteration);
       }
       /*...*/
    }

Les résultats pour n<2 sont incohérents.

Enfin, il y a des conventions en Java : les méthodes commencent toujours par une minuscule.

Comme ça (dans le même esprit d'algorithme), ça me semble plus clair, non ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class DessinTriangle {
 
    private final static char FILL = '-';
    private final static char BORDER = '*';
    private final static char BACKGROUND = 'x';
 
    public static void triangle(int n) {
    	if ( n>0 ) {
    		triangle(n, 0);
    	}
    }
    private static void triangle(int n, int iteration) {
        int nombreEspaceExterne = iteration + 1; // nombre d'espaces de chaque côté
        int longueur = n * 2 + 1; // longueur de ligne
 
        char[] ligne = new char[longueur]; 
 
        if ( nombreEspaceExterne>0 ) {
           Arrays.fill(ligne, 0, nombreEspaceExterne, BACKGROUND); // espaces à gauche
           Arrays.fill(ligne, ligne.length-nombreEspaceExterne, ligne.length, BACKGROUND); // espaces à droite
        }
 
        final int bordureGauche = nombreEspaceExterne; // position bordure
        final int bordureDroite = ligne.length - bordureGauche - 1; // position bordure
     	ligne[bordureGauche]=BORDER; // bordure gauche
	ligne[bordureDroite]=BORDER; // bordure droite
 
	if( bordureDroite>bordureGauche ) {
	   Arrays.fill(ligne, bordureGauche+1, bordureDroite, iteration==0?BORDER:FILL); // pas de remplissage pour la ligne de base, mais une bordure
	}
 
        System.out.println(new String(ligne));
 
        iteration++;
        if (iteration < n) {
        	triangle(n, iteration);
        }
 
 
    }
 
    public static void main(String[] args) {
    	triangle(7);
    }
}

Voire comme ça (sans espaces supplémentaires superflues) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class DessinTriangle {
 
    private final static char FILL = '-';
    private final static char BORDER = '*';
    private final static char BACKGROUND = ' ';
 
    public static void triangle(int n) {
    	if ( n>0 ) {
    	   triangle(n-1, 0);
    	}
    }
    private static void triangle(int n, int iteration) {
        int nombreEspaceExterne = iteration; // nombre d'espaces de chaque côté
        int longueur = n * 2 + 1; // longueur de ligne
 
        char[] ligne = new char[longueur]; 
 
        if ( nombreEspaceExterne>0 ) {
           Arrays.fill(ligne, 0, nombreEspaceExterne, BACKGROUND); // espaces à gauche
           Arrays.fill(ligne, ligne.length-nombreEspaceExterne, ligne.length, BACKGROUND); // espaces à droite
        }
 
        final int bordureGauche = nombreEspaceExterne; // position bordure
        final int bordureDroite = ligne.length - bordureGauche - 1; // position bordure
     	ligne[bordureGauche]=BORDER; // bordure gauche
	ligne[bordureDroite]=BORDER; // bordure droite
 
	if( bordureDroite>bordureGauche ) {
	    Arrays.fill(ligne, bordureGauche+1, bordureDroite, iteration==0?BORDER:FILL); // pas de remplissage pour la ligne de base, mais une bordure
	}
 
        System.out.println(new String(ligne));
 
        if (iteration < n) {
            iteration++;
            triangle(n, iteration);
        }
 
 
    }
 
    public static void main(String[] args) {
    	Triangle(7);
    }
}

16/07/2015, 16h13
pendoRa

La mise en pratique des différentes suites mathématiques (Fibonacci..) est un bon exercice également si tu souhaites progresser dans la compréhension des boucles.

* Ecrire un programme qui affiche les 45 premiers éléments de la suite de Fibonacci.
* 1 1 2 3 5 8 13 21 34 55 89 ...
* Chaque élément de la suite (sauf les deux premiers) est calculé en additionnant les deux éléments qui le précèdent.
*

Bon courage.
17/07/2015, 10h38
serna

grand merci drigo pour la clarification du code ( qui n'est pas de moi hien , je suis pas encore avancé pour faire ce genre de code, même moche)
c’est très instructif , ça va me faire progresser et me donne de bonnes pratiques.

merci pandora
suite de Fibonacci, triangle de Pascal , ce sont effectivement de bon exercices

bon week end !