java pyramide codage

Bonsoir, voici le code que j'ai fais afin de créer une pyramide :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private static void pyramideVersion1(int n) {
      int nbreCroix = 1;
      int nbreEspace = n;
 
       //nombre de lignes
      for(int i = 1; i<=n; i++){
 
       //nbrCroix
         for(int j = 1; j<=nbreCroix; j++){
            System.out.print('X');
         }
 
      //nbrEspaces
         for(int j = 0; j<=nbreEspace; j++){
            System.out.print(' ');
         }
         System.out.println();
         nbreCroix++;
         nbreEspace--;
      }

Mais au lieu de ça, cela m'affiche ceci :

X
XX
XXX
XXXX

Comment changer mon code ? Merci.

Salut,

Si c'est quelque chose comme ça que tu veux obtenir :
   X
  XXX
 XXXXX
XXXXXXX
Il suffit d'analyser chaque ligne, compter les caractères et généraliser en cherchant un lien avec l'indice de boucle et/ou un lien entre chaque comptage (on définira soit une fonction avec i en paramètre, soit des suites pour le nombre d'espaces et de X pour chaque ligne pour définir comment les faire varier à chaque ligne...)

On peut mettre ces nombres dans un tableau, ce qui permet de voir rapidement ces liens, et comprendre comment faire évoluer les indices de boucles. Les espaces après les X importent peu, mais c'est le même nombre qu'avant, donc facile à déterminer quand on sait comment traiter celles qui sont avant les X.

ligne indice de boucle nombre d'espaces nombre de X

première 0 3 1

deuxième 1 2 3

troisième 2 1 5

quatrième 3 0 7

On voit très bien comment faire évoluer les comptages (initialisation en fonction de nombre de lignes, pas d'incrémentation ou de décrémentation selon) ou comment les calculer en fonction de l'indice de boucle...

Serait-il possible de procéder sans tableau ? Juste avec des for imbriqués ? Car le tableau m'est encore méconnu et le but est de réussi grace à des for imbriqués...

Je n'ai jamais parlé d'utiliser un tableau Java. J'ai utilisé un tableau graphique pour te faire apparaître les rapports entre valeurs, verticaux (dans l'ordre des itérations) et horizontaux (rapports entre différentes informations nécessaires pour construire les lignes (des variables pour définir les boucles d'espaces et de X)). Ce qui devrait de faire comprendre comment écrire le code, c'est-à-dire, oui, des boucles imbriquées, du genre :

Soit

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// mode 1 : par variables et incrémentation ou décrémentation, dans la boucle principale qui détermine la hauteur (en traitant chaque ligne)
public static void main(String[] args) {
 
    int n=10;// nombre de lignes (hauteur de la pyramide)
 
    int nombreespace=/* quelque chose en fonction de n ou pas, déduit du tableau que j'ai montré dans mon premier message */;
    int nombrex=/* quelque chose en fonction de n ou pas, déduit du tableau que j'ai montré dans mon premier message */;
 
    for(int i=0; i<n; i++) {
        for(int j=0; j<nombreespace; j++) {
            System.out.print(' ');
        }
        for(int j=0; j<nombrex; j++) {
            System.out.print('X');
        }
        System.out.println();
        nombreespace/* incrémentation ou décrémentation déduite du tableau que j'ai montré dans mon premier message */;
        nombrex/* incrémentation ou décrémentation déduite du tableau que j'ai montré dans mon premier message */;
    }
 
}

soit

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// mode 2 : par calcul des borne de boucle dans chaque itération de la boucle principale 
public static void main(String[] args) {
 
    int n=10;// nombre de lignes (hauteur de la pyramide)
 
    for(int i=0; i<n; i++) {
 
        int nombreespace=/* calcul en fonction de i et n, ou pas, déduit du tableau que j'ai montré dans mon premier message */;
        int nombrex=/* calcul en fonction de i et n, ou pas, déduit du tableau que j'ai montré dans mon premier message */;
        for(int j=0; j<nombreespace; j++) {
            System.out.print(' ');
        }
        for(int j=0; j<nombrex; j++) {
            System.out.print('X');
        }
        System.out.println();
 
    }
 
}

je n'ai absolument pas compris

Pour afficher la pyramide il faut afficher des lignes successives composées d'espaces (un certain nombre d'espaces) et de X (un certain nombre de X). Afficher des lignes successives veut dire une boucle, et pour afficher chaque ligne, il faut déterminer combien d'espaces et combien de X il faut afficher.
Pour déterminer ces nombres d'espaces et de X, je t'ai dit qu'il suffisait d'écrire le résultat qu'on voulait (sur du papier, un fichier texte, etc), compter les espaces et les X et les mettre dans un tableau (sur du papier, un fichier texte, etc), ce qui permettait de voir (lire, observer, réfléchir, déterminer comment on passe de l'une à l'autre) les séries de nombres, en lignes (horizontales) ou en colonnes (verticales), afin de déterminer les formules qui permettaient de les calculer afin d'écrire le code final. Je t'ai même mâché le boulot en te donnant le tableau pour 5 lignes.

Il y a plusieurs façons de déterminer l'algorithme et je t'ai donné deux canevas (90% du travail), un basé sur la variation (et je t'ai même indiqué quel type de variation) de deux variables déterminant la série de nombre d'espaces et de X pour chaque ligne, et une autre basé, sur le calcul des nombres d'espaces et de X pour chaque ligne, en fonction de l'indice de boucle sur les lignes et du nombre de lignes.

Déjà réponds à ces questions (Sachant que la variation de l'indice de boucle i (une boucle for(int i=0;i<n;i++)) donne la série suivante : 0 1 2 3) :

La série de nombres qui constitue le nombre d'espaces pour chaque ligne est (tirée du tableau donc) : 3 2 1 0.

Quelle est la relation entre chaque nombre de cette série ? Autrement dit, comment écrire une boucle for qui affiche ces nombres ?
Quelle est la relation entre chaque nombre et l'indice i d'une boucle for(int i=0;i<n;i++). Autrement dit comment calculer le nombre pour chaque i pour l'afficher par cette boucle.
La série de nombres qui constitue le nombre de X pour chaque ligne est (tirée du tableau donc) : 1 3 5 7.

Quelle est la relation entre chaque nombre de cette série ? Autrement dit, comment écrire une boucle for qui affiche ces nombres ?
Quelle est la relation entre chaque nombre et l'indice i d'une boucle for(int i=0;i<n;i++). Autrement dit comment calculer le nombre pour chaque i pour l'afficher par cette boucle.

Si tu réponds à ces questions tu as ce qu'il faut pour remplir les trous dans les canevas. Les questions 1-1 et 2-1 pour le premier canevas. Les questions 1-2 et 2-2 pour le second.

Bon j'ai essayé voici ce que ca donne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 private static void pyramideVersion1(int n) {
 
     int hauteurPyramide = n;
 
 
      for(int i=1; i<=hauteurPyramide; i++) {
 
         for(int j=1; j<=hauteurPyramide; i++){
 
            System.out.print(' ');
         }
 
         for(int j=1; j<=2*i-1; j++) {
 
            System.out.print('X');
         }
         System.out.println();
      }
   }

la compilation OK mais rien n’apparaît à l’exécution

Ton programme n'affiche pas rien, mais une infinité d'espaces !

Parce que la première des deux boucles imbriquées est infinie :
Code:

1 2 3 4 5 for(int j=1; j<=hauteurPyramide; i++){ System.out.print(' '); }
En effet, j ne varie pas (puisque c'est i qui varie), et reste donc toujours inférieur ou égal à hauteurPyramide.

Oui effectivement ! Code toujours faux :(

Et donc ? Ça veut dire que tu ne vois pas la solution ?
Code:

1 2 3 4 5 for(int j=1; j<=hauteurPyramide; j++){ System.out.print(' '); }
Et là ton programme affiche pour n=10:
          X
          XXX
          XXXXX
          XXXXXXX
          XXXXXXXXX
          XXXXXXXXXXX
          XXXXXXXXXXXXX
          XXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXX
Bah oui forcément ta borne supérieur de boucle c'est hauteurPyramide, une valeur fixe. Qu'elle soit bonne ou pas, on sait bien que le nombre d'espaces au début de chaque ligne n'est pas une valeur fixe, donc ce n'est pas la bonne borne supérieure. Au risque de me répéter encore une fois, il suffit d'observer et de compter les espaces pour déterminer la formule pour déterminer cette borne supérieure :

sur la dernière ligne, il n'y aucune espace, donc la valeur c'est 0
sur l'avant dernière, c'est 1, puis 2, etc...
quelle formule à partir de i = 10 et n=10 donne 0, et i = 9 et n = 10 donne 1, et i = 8 et n = 10 donne 2, etc ?

OK j'ai réussi !!

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
   private static void pyramideVersion1(int n) {
 
      int nbreCroix = n;
      int espace = 1;
 
   //determiner le nombre de lignes
      for(int i =1; i<=n; i++){
 
      //nombre d'espaces
         for(int j=n; j>=i; j--){
            System.out.print(' ');
         }
 
         //nombre de croix
         for(int j=1; j<=(2*i-1); j++){
            System.out.print('X');
         }
         System.out.println();
      } 
 
   	// TODO 
 
   }

un peu par coup de chance ! Je n'ai paxs compris comment ca se fait que cette formule aies fonctionné. J'ai l'impression que mes bases en java ne sont pas très bonnes.

Citation:

Envoyé par imnamn

OK j'ai réussi !!

Bravo \o/

Citation:

Envoyé par imnamn

un peu par coup de chance ! Je n'ai paxs compris comment ca se fait que cette formule aies fonctionné. J'ai l'impression que mes bases en java ne sont pas très bonnes.

Dans le contexte ce n'est pas vraiment un problème de Java, mais d'algorithmique. Et encore, l'algorithmique ici est basique et c'est surtout de l'arithmétique.

Pour l'explication de :

Code:

1
2
3
for(int j=n; j>=i; j--){
            System.out.print(' ');
}

C'est une façon de faire la boucle en utilisant la formule n-i pour calculer le nombre d'espaces.

Pour résumé, voici les 2 solutions des deux canevas que je t'ai donnés précédemment. Mes boucles vont de 0 à n exclu, parce que c'est plus courant en Java (comme les boucles sur les tableaux, les listes, etc) et ça rend les formules souvent plus simple (0*k étant égal à 0), alors que les tiennes vont de 1 à n inclus. Mais c'est pareil, il y a juste une différence de 1 pour les valeurs de bornes.

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
/** 
 * mode 1 : par variables, décrémentation et incrémentation (par 2)
 * 
 * @param n nombre de lignes (hauteur de la pyramide)
 */
public static void pyramide(int n) {
 
    int nombreespace=n-1;
    int nombrex=1;
 
    for(int i=0; i<n; i++) {
 
        for(int j=0; j<nombreespace; j++) {
            System.out.print(' ');
        }
 
        for(int j=0; j<nombrex; j++) {
            System.out.print('X');
        }
 
        System.out.println();
 
        nombreespace--;
	nombrex+=2;
    }
 
}

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
/** 
 * mode 2 : par calcul des bornes de boucle dans chaque itération de la boucle principale 
 *
 * @param n nombre de lignes (hauteur de la pyramide)
 */
public static void pyramide(int n) {
 
    for(int i=0; i<n; i++) {
 
        int nombreespace=n-i-1;
        int nombrex=(i*2)+1;
 
        for(int j=0; j<nombreespace; j++) {
            System.out.print(' ');
        }
 
        for(int j=0; j<nombrex; j++) {
				System.out.print('X');
        }
 
        System.out.println();
 
    }
 
}

Il y'en a bien sûr beaucoup d'autres, comme par exemples :

Merci merci !!!

ligne	indice de boucle	nombre d'espaces	nombre de X
première	0	3	1
deuxième	1	2	3
troisième	2	1	5
quatrième	3	0	7