Imprimer le diamant écanvas (‘*’) en C avec des boucles nestedes?

Je veux pouvoir imprimer un diamant comme celui-ci lorsque l’utilisateur entre 5 pour le diamant. Mais fonctionnera également pour toute valeur impaire et supérieure à 0.

entrez la description de l'image ici

J’ai un code qui fonctionne pour faire un diamant pour une entrée utilisateur de 5 mais ne fonctionnera pas pour toutes les entrées de nombres impairs ..

half = (size/2)+1; for (a=1; a <= half ; a++) /*top to mid row of diamond*/ { for (b=a; b<half;b++) { printf(" "); } for (c= size -2* a; c <= half; c++) { printf("*"); } printf("\n"); } for (a = 1; a 0;b--) { printf(" "); } for (c = size-2*a; c >0 ;c--) { printf("*"); } printf("\n"); } return 0; } 

Toute aide serait grandement appréciée. Merci.

Mike

Presque certainement les devoirs alors voici un indice.

Comptez le nombre d’espaces avant une ligne et le nombre d’écanvass dans cette ligne. Vous recherchez une relation entre le numéro de ligne et ces deux valeurs.

Ensuite, vous pouvez utiliser deux boucles for consécutives, l’une augmentant le nombre d’écanvass et l’autre le diminuant.

Dans chacune de ces boucles, il y aurait deux autres boucles consécutives pour imprimer le nombre d’espaces requirejs, suivis du nombre d’écanvass requirejs, suivis d’un caractère de nouvelle ligne.


Si vous rencontrez toujours des problèmes après avoir lu ce qui précède, considérez ceci. Pour une entrée de (impair, au fur et à mesure que vous indiquez que vous imposez vos commentaires) n , le compte des espaces commence à (n - 1) / 2 et le nombre des écanvass à 1 . Pour chaque ligne suivante, le nombre d’espaces est réduit de 1 et le nombre d’écanvass augmente de 2 .

Cela fonctionne jusqu’au point où le nombre d’espaces atteint 0 , puis vous vous retournez et vous effectuez l’inverse, en vous assurant de ne pas imprimer deux fois la ligne médiane.

Une fois que le nombre d’écanvass atteint 0 , vous avez terminé.

Il ne rest plus qu’à transformer cette spécification en code 🙂


Maintenant, puisque vous avez indiqué dans vos commentaires que vous souhaitiez créer votre propre solution plutôt que de simplement recevoir du code, je me sens à l’aise de vous donner quelque chose contre lequel vous pouvez vérifier votre propre solution. Voici le pseudo-code que j’utiliserais:

 # Input data, check and init counters. input n make sure n is odd and greater than 2 set numspaces to (n-1) / 2 set numstars to 1 # Gradually get wider until just before middle line. while numspaces > 0: for i = 1 to numspaces: output " " for i = 1 to numstars: output "*" output newline subtract 1 from numspaces add 2 to numstars # Gradually get thinner until end. while numstars > 0: for i = 1 to numspaces: output " " for i = 1 to numstars: output "*" output newline add 1 to numspaces subtract 2 from numstars 

Et, comme dernier exercice, vous pouvez reformer:

  for i = 1 to numspaces: output " " for i = 1 to numstars: output "*" output newline 

dans une fonction séparée, car il est commun entre les deux boucles.


Et maintenant, puisque votre propre code fonctionne, voici le code Python que j’ai utilisé pour la preuve de concept, inclus pour plus de précision:

 def lineout (sp, st): s = "" for i in range (sp): s = "%s "%(s) for i in range (st): s = "%s*"%(s) print s n = 21 numspaces = (n-1) / 2 numstars = 1 while numspaces > 0: lineout (numspaces, numstars) numspaces -= 1 numstars += 2 while numstars > 0: lineout (numspaces, numstars) numspaces += 1 numstars -= 2 

Vous pourriez probablement l’écrire plus succinctement en Python si vous utilisiez les fonctionnalités les plus modernes, mais cela irait plutôt à l’encontre de l’objective de compréhension rapide et de traduction facile. Il suffit de changer n pour le nombre que vous voulez (impair et supérieur à deux, à condition que le diamant résultant tienne dans votre terminal) et profitez de la sortie 🙂

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

Il y a deux choses qui se produisent ici:

  1. Changements d’indentation (-1 à “moyen”, +1 “après”)

  2. Le nombre d’écanvass change (+2 à “moyen”, -2 “après”)

Maintenant, cela pourrait être fait avec deux boucles (une pour le haut vers le “milieu” et une “après”), mais les valeurs peuvent également être déterminées avec un peu de calcul. Explorons cela 🙂

Voici les chiffres:

  s (espaces) x (écanvass) n (numéro de ligne)
 __X 2 1 0
 _XXX 1 3 1
 XXXXXX 0 5 2
 _XXX 1 3 3
 __X 2 1 4 

Commencez par noter que s est symésortingque par rapport au “milieu”:

  • s = abs (2 – n)

Et puis que x est lié à s (par 2 comme indiqué dans les deltas ci-dessus):

  • x = 5 – (s * 2) = 5 – (abs (2 – n) * 2)

J’espère que ça donne un aperçu!

Vous suivez probablement le cours d’introduction au C actuellement, et comme tout le monde, je vous déconseille de copier, mais voici une réponse:

Pour simplifier la réponse, il vous suffit de connaître le nombre d’espaces et d’écanvass à imprimer.

La séquence est la suivante: [espaces d’impression] [écanvass d’impression] [espaces d’impression] [print ‘\ n’] .
Observez que dans la rangée du milieu nous aurions besoin de: (0) espaces, (numStars) écanvass, (0) espaces .
Dans la rangée en haut et en bas, nous aurions besoin de: (1) espace, (numStars – 2) écanvass, (1) espace .
Un Ainsi de suite…

Cela devrait vous donner le sentiment que pour compter le nombre d’espaces, vous devez compter la distance depuis la rangée du milieu. Notez également qu’à chaque rangée éloignée du milieu, le nombre d’écanvass décroît de 2.

 #include  #include  int main(int argc, char** argv) { int num, middle, spaceCount, starCount; printf("Enter a num:"); scanf("%d",&num); middle = (num-1)/2; for (int i = 0; i < num; i++){ spaceCount = abs(middle - i); starCount = num - 2*abs(middle - i); for(int c = 0; c < spaceCount; c++) printf(" "); for(int c = 0; c < starCount; c++) printf("*"); for(int c = 0; c < spaceCount; c++) printf(" "); printf("\n"); } return 0; } 

Puisque nous calculons la distance entre la rangée actuelle et la médiane, nous devons connaître la valeur absolue. fonction abs est la fonction standard C pour le faire.

J’ai eu du mal avec ça un peu. Aussi, désolé, mon code final est C ++, pas un C ssortingct, car je n’ai pas utilisé le C depuis 10 ans. Voici une explication plus verbeuse pour ceux qui essaient de comprendre comment résoudre cela pour vous-même. Avant de commencer, vous pouvez vous aider en commençant par une déclaration du type:

int numStars = 1, numSpaces = 10;

numSpaces n’a pas d’importance tant qu’il est suffisamment petit pour tenir sur votre écran … vous pouvez twigr n’importe quel nombre et le tester plus tard. Ensuite, déterminez votre algorithme et, plus tard, vous pourrez gérer la saisie.

De plus, le nombre d’espaces APRÈS les écanvass n’a aucune incidence sur ce problème.

Ensuite, résolvez le problème de la sortie de la partie supérieure du losange. J’ai utilisé une boucle de compteur pour imprimer des espaces jusqu’à ce que j’aie imprimé le nombre d’espaces de la première ligne, puis une seconde boucle (non nestede) pour imprimer le nombre d’écanvass nécessaires pour cette ligne. Nous soaps que dans la ligne 1, nous devons imprimer un espace 10 fois et une écanvas une fois.

Une fois que la ligne a le nombre d’espaces et d’écanvass requirejs, vous accédez à la nouvelle ligne (“\ n” ou endl). Mais au rang suivant, vous devez imprimer 2 écanvass de plus et 1 espace en moins. Donc, vous devez incrémenter / décrémenter de manière appropriée.

Lorsque vous arrivez à la rangée avant la rangée du milieu, vous vous arrêtez. En d’autres termes, la boucle supérieure doit continuer lorsque numSpaces est supérieur à 0. À la fin du dernier passage dans la boucle, numSpaces est décrémenté à 0, mais la ligne ne sera pas imprimée avec 0 espace et n écanvass (2 écanvass). pour chaque espace que vous avez commencé avec). Cela se passe dans votre prochaine boucle …

Ensuite, vous pouvez exécuter la deuxième boucle qui inverse votre incrément / décrément à la fin, mais qui est sinon presque identique. Seulement cette fois, il devrait imprimer 0 espaces et 10n écanvass. Ensuite, la nouvelle ligne et enfin diminuer le numStars de 2 et augmenter numSpaces de 1.

Si vous n’utilisez pas encore de fonctions ou n’êtes pas autorisé à l’implémenter, c’est à peu près tout. Cependant, vous pouvez facilement appeler une fonction en lui passant numSpaces / numStars, pour chacune des boucles afin d’éliminer le code en double.

Voici mon code en C ++:

 #include  using namespace std; int main() { int numStars = 1, numSpaces = 10; while (numSpaces > 0) { for (int i = 0; i < numSpaces; i++) { cout << " "; } for (int i = 0; i < numStars; i++) { cout << "*"; } cout << "\n"; numStars += 2; numSpaces--; } while (numStars > 0) { for (int i = 0; i < numSpaces; i++) { cout << " "; } for (int i = 0; i < numStars; i++) { cout << "*"; } cout << "\n"; numStars -= 2; numSpaces++; } return 0; } 

Je ne veux pas vous donner le code, vous devriez apprendre.

Le nombre saisi correspondra à la largeur du losange. Veillez donc à établir une relation entre les espaces et les astérisques ne dépassant pas ce nombre.

L’idée principale serait de commencer par un astérisque et de l’incrémenter de deux à chaque fois jusqu’à ce que le nombre saisi soit atteint.

En outre, faites quelque chose pour éviter une erreur si l’utilisateur entre un nombre pair.

ici le code avec matlab

 clear all, clc n=input('Input an Odd Number '); for i=1:(n+1)/2 for m=1:(n+1)/2-i fprintf(' '); end for j=1:(2*i)-1 fprintf('*'); end fprintf('\n'); end for k=i-1:-1:1 for m=1:(n+1)/2-k fprintf(' '); end for j=1:(2*k)-1 fprintf('*'); end fprintf('\n'); end 
  static void Main(ssortingng[] args) { //check this out more optimized code hope it will be help full. for (int row=-2;row<=2;row++) { for (int col=-2;col<=2;col++) { if (Math.Abs(row)+Math.Abs(col)<=2) { Console.Write("*"); } else { Console.Write(" "); } } Console.WriteLine(); } Console.ReadKey(); } 
 #include  using namespace std; int main() { int n=0, star=0, space=0, ct2=0, ct3=1; cin >> n; ct2=n/2; for(int ct=0; ct< (n/2); ct++) { for(space; space 
 #include main() { int i,j,k,n; scanf("%d",&n); n=(n+1)/2; for(i=1;i<=n;i++) { for(j=n;j>=i;j--) printf(" "); for(k=1;k<=(2*i-1);k++) printf("*"); printf("\n"); } for(i=1;i<=(n-1);i++) { for(j=0;j<=i;j++) printf(" "); for(k=(2*n-3);k>=(2*i-1);k--) printf("*"); printf("\n"); } } 

Salut, je suis à la meilleure solution pour ce problème en moins de lignes

 int b=0; for(int a=0;b<=50;a=(b<=25) ? a+2 : a-2 ){ b+=2; for(int b=25-a;b>0;b-=2){ printf(" "); } for(int c=0;c<=a;c++){ printf("*"); } printf("\n"); } 

Produire un diamant en C par un astérisque

 #include main() { int n, i, j; printf("Enter a number: "); scanf("%d",&n); /* Create up arrow. */ for(i=1; i<=n; i++) { /* Left side. */ for(j=i; j<=n+1; j++) { printf(" "); } for(j=1; j<=1; j++) { printf("*"); } /* Middle. */ for(j=1; j