Comment puis-je construire une pyramide en utilisant un programme en boucle, étant donné un nombre de lignes par l'entrée d'un utilisateur? Comme
* *** ***** *******
J'ai essayé de regarder plusieurs vidéos et de lire des articles sur la logique de cela, mais les instructeurs n'étaient pas compréhensibles ou ils ont sauté des lignes de raisonnement.
I sachez que chaque ligne augmente de 2 étoiles, et je sais que parce que chaque ligne a un nombre impair d'étoiles, je peux définir le nombre d'étoiles dans une ligne comme 2n + 1 où n est un entier. J'ai remarqué qu'un triangle à 2 rangées a une base de 3 étoiles, un triangle à 3 rangées a une base de 5 étoiles, et ainsi de suite. Donc, pour une nième ligne, la base des triangles est n + (n-1), qui est 2n-1. Par exemple, r_5: base = 9 étoiles. La prochaine chose dont je sais que mon programme doit tenir compte est l'espacement. J'ai remarqué, à partir de la base, l'espacement augmente de 2 à chaque rangée jusqu'à ce que nous ayons n-1 espaces sur la première moitié et un autre n-1 espaces sur la seconde moitié, en d'autres termes, l'espacement augmente à partir de la base jusqu'à ce qu'il soit supérieur ou égal à 2b-2.
Je pense que tout ce qui couvre l'essentiel qu'un programme java aurait besoin de savoir: le nombre d'étoiles par ligne, la taille de la base et l'espacement. Mais comment traduire tout cela en termes de boucle for while?
3 Réponses :
Voici mon implémentation -
public static String repeat(String str, int times) {
return new String(new char[times]).replace("\0", str);
}
public void createPyramid(int size) {
for (int i = 1; i <= size; i += 2) {
int numSpaces = (size - i) / 2;
System.out.println(repeat(" ", numSpaces) + repeat("*", i) + repeat(" ", numSpaces));
}
}
Appelez la méthode comme - createPyramid (7); devrait vous donner la sortie souhaitée. Vous pouvez augmenter la taille pour une pyramide plus grande.
La variable est itérée pour la taille de la pyramide. Et le nombre d'étoiles sur chaque ligne augmente de 2 à partir de 0. Là je incrémente de 2. Les espaces vides seront égaux à size - number of * 's mais ils doivent être répétés avant et après les * symétriquement, nous le divisons par 2. Cela donnera le nombre d'espaces avant et après les * et au milieu il suffit d'imprimer les * dont le nombre est donné par i.
Donc, nous les imprimons enfin.
La fonction de répétition crée une chaîne formée à partir du paramètre str répété fois fois. par exemple - si nous appelons repeat ("abc", 3) , il renverra "abcabcabc".
Notez que, si nous désignons le numéro de ligne actuel par "ligne" commençant à 0 et le nombre total de lignes par "n",
Nombre d'étoiles dans chaque ligne = 2 * ligne + 1
Nombre d'espaces de début (ou de fin) dans chaque ligne = n - ligne - 1
Nous pouvons simplement générer la pyramide en utilisant ceci règle:
..***..
Vous pouvez également aborder par le milieu et développer. Notez qu'il y a une colonne constante d'une étoile (*) au milieu, et de chaque côté, une seule étoile est ajoutée dans chaque ligne à chaque fois. Et le reste sont des espaces.
*** ^ This middle one is the first star
Explication:
*
*
...*...
Sur la 2ème itération (ligne == 1) si nous appliquons la même logique: 1.
*
2.
int n = 4;
for(int line=0; line <n ; line++){
StringBuilder sb = new StringBuilder("*");
int spacesToAppendOnBothSides = n-line-1;
int starsToAppendOnBothSides = line;
for(int idx=0; idx<starsToAppendOnBothSides; idx++){
sb.insert(0, "*"); //appends to the beginning
sb.append("*"); //appends to the end
}
for(int idx=0; idx<spacesToAppendOnBothSides; idx++){
sb.insert(0, " ");
sb.append(" "); //NOTE: You may exclude this line to avoid adding trailing spaces
}
System.out.println(sb.toString());
}
3.
int n = 4;
for (int line = 0; line < n; line++) {
StringBuilder sb = new StringBuilder();
int starsToAppend = 2 * line + 1;
int spaceToAppend = n - line - 1;
while (spaceToAppend-- > 0) sb.append(" ");
while (starsToAppend-- > 0) sb.append("*");
System.out.println(sb.toString());
}
Assez simple une fois que vous comprenez la logique. Il existe plusieurs façons de procéder, mais celles-ci sont parmi les plus simples :)
Supposons que vous deviez imprimer une pyramide de n lignes. Vous pouvez voir que la ligne i (où i est compris entre 1 et n ) commencera par des espaces ni et aura (i-1) * 2 + 1 astérisques:
for (int i = 1; i <= n; ++i) {
int spaces = n-i;
int stars = (i-1)*2+1;
for (int j = 1; j <= spaces; ++j) {
System.out.print(' ');
}
for (int j = 1; j <= stars; ++j) {
System.out.print('*');
}
System.out.println();
}
Pensez-y clairement: une boucle for permettra au corps de la boucle d'être exécuté X fois, où X est un nombre fini et connu. Pensez à ce qui dans votre pyramide est un nombre connu et fini? Quelle est la seule chose que votre programme doit demander à l'utilisateur avant de pouvoir faire son travail?
Tout comme une note à OP, vous allez avoir besoin de plusieurs boucles. Gardez à l'esprit que les boucles for sont utilisées lorsque vous connaissez le nombre d'itérations que vous avez, tandis que les boucles while sont utilisées lorsque le nombre d'itérations est indéterminé. Compte tenu de ces bribes de connaissances et de votre compréhension antérieure de l'algèbre, faites ce que dit Stephen C et essayez-le. Ignorez les solutions affichées - quelque chose me dit que vous savez déjà que vous tirerez davantage parti de la lutte pour la réponse.
J'ai essayé de le coder moi-même, mais en général, j'obtenais juste d'étranges étoiles diagonalisées ou une colonne d'étoiles. Tenter cela moi-même a aidé dans une certaine mesure, cela m'a fait réaliser que plusieurs boucles sont nécessaires, par exemple. Je suis content d'avoir reçu beaucoup de réponses ici, je vais essayer de nouveau quand je me réveillerai plus tard dans la journée