Discussion :

[imnamn]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[joel.drigo]

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...

[imnamn]

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...

[joel.drigo]

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 :

1. Soit
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   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 */;
       }
    
   }

2. soit
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   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();
    
       }
    
   }

[imnamn]

je n'ai absolument pas compris

[joel.drigo]

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) :

1. La série de nombres qui constitue le nombre d'espaces pour chaque ligne est (tirée du tableau donc) : 3 2 1 0.
   
   1. Quelle est la relation entre chaque nombre de cette série ? Autrement dit, comment écrire une boucle for qui affiche ces nombres ?
   2. 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.
2. La série de nombres qui constitue le nombre de X pour chaque ligne est (tirée du tableau donc) : 1 3 5 7.
   
   1. Quelle est la relation entre chaque nombre de cette série ? Autrement dit, comment écrire une boucle for qui affiche ces nombres ?
   2. 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.

[imnamn]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[joel.drigo]

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[imnamn]

Oui effectivement ! Code toujours faux

[joel.drigo]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

1. sur la dernière ligne, il n'y aucune espace, donc la valeur c'est 0
2. sur l'avant dernière, c'est 1, puis 2, etc...
3. 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 ?

[imnamn]

OK j'ai réussi !!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[joel.drigo]

OK j'ai réussi !!

Bravo \o/

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/** 
 * 
 * @param n nombre de lignes (hauteur de la pyramide)
 */
public static void pyramide(int n) {
 
    StringBuilder x = new StringBuilder("X");
    StringBuilder espaces = new StringBuilder();
    Stream.generate(()->" ").limit(n).forEach(espaces::append);
 
    for(int i=0; i<n; i++) {
 
        espaces.deleteCharAt(espaces.length()-1);
 
        System.out.print(espaces);
        System.out.print(x);
        System.out.println();
 
        x.append("XX");
 
    }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/** 
 * 
 * @param n nombre de lignes (hauteur de la pyramide)
 */
public static void pyramide(int n) {
 
    if ( n>0 ) {
        StringBuilder ligne = new StringBuilder(" ".repeat(n)).replace(n-1, n, "X");
 
        for(int i=0; i<n; i++) {
	    System.out.println(ligne.substring(i));
	    ligne.append("XX");
	}
    }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/** 
 * 
 * @param n nombre de lignes (hauteur de la pyramide)
 */
public static void pyramide(int n) {
 
    if ( n>0 ) {
        String ligne = " ".repeat(n-1)+"X".repeat(n*2-1);
        for(int i=0; i<n; i++) {
            System.out.println(ligne.substring(i,i*2+n));
        }
    }
 
}

[imnamn]

Merci merci !!!