Impression étoile ('*') diamant en C avec des boucles imbriquées?

Presque certainement devoirs alors voici un indice.

De compter le nombre d'espaces avant une ligne et le nombre d'étoiles dans cette ligne. Ce que vous cherchez est un relationsip entre le numéro de la ligne et de ces deux valeurs.

Ensuite, vous pouvez utiliser deux fois de suite for boucles, une augmentation du nombre d'étoiles et l'autre en la diminuant.

Dans chacune de ces boucles de deux plus consécutives boucles d'imprimer le nombre requis de places de suivi par le nombre d'étoiles suivie par un caractère de saut de ligne.

---

Si vous rencontrez toujours des difficultés après avoir lu ci-dessus, considérez ceci. Pour l'entrée (bizarre, comme vous le dites vous respecter dans vos commentaires) n, l'espace commence à (n - 1) /2 et le nombre d'étoiles à 1. Pour chaque ligne, l'espace réduit par 1 et le nombre d'étoiles augmente par 2.

Qui fonctionne jusqu'au moment où l'espace atteint 0, puis vous tournez autour, et aller dans l'autre sens, de s'assurer que vous n'avez pas l'impression que le milieu de la ligne deux fois.

Une fois que le nombre d'étoiles atteint 0, vous avez terminé.

Maintenant, vous avez juste à tourner cette spécification dans le code 🙂

---

Maintenant, puisque vous avez indiqué dans les commentaires qui vous êtes intéressé à faire votre propre solution plutôt que d'être simplement remis le code, je me sens à l'aise en vous donnant quelque chose que vous pouvez vérifier votre propre solution contre. Voici le pseudo-code que j'ai utiliser:

# 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, à la fin de l'exercice, vous pouvez restructurer:

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

dans une autre fonction, car il est commun entre les deux boucles.

---

Et maintenant, puisque vous avez votre propre code de travail, voici le code Python que j'ai utilisé pour la preuve de concept, inclus pour l'intégralité:

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 de façon plus succincte en Python si vous avez utilisé le plus de fonctionnalités modernes, mais qui serait plutôt l'encontre de l'objectif de compréhension rapide et facile de la traduction. Il suffit de changer n à ce que le numéro que vous souhaitez (impair et supérieur à deux, en fournissant la résultante de diamant ira parfaitement dans votre terminal) et de profiter de la sortie 🙂

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

Vous êtes probablement à la prise d'introduction de classe C à l'instant, et comme tout le monde, je voudrais vous décourager de la copie, mais voici une réponse:

Pour rendre la réponse simple, tout ce que vous devez savoir, c'est combien d'espaces et les étoiles à imprimer.

La séquence est la suivante: [imprimer des espaces] [imprimer étoiles] [imprimer des espaces] [print '\n'].

Observer que, dans la rangée du milieu, nous aurions besoin de: (0) espaces, (numStars) étoiles, (0) espaces.

Dans la ligne ci-dessus et ci-dessous, nous aurions besoin de: (1) de l'espace, (numStars - 2) étoiles, (1) l'espace.

Une sorte de suite...

Cela devrait vous donner le sentiment de compter le nombre d'espaces, vous devez compter la distance à partir de la rangée du milieu. Notez également que chaque rangée loin de la moyenne, le nombre d'étoiles diminue par 2.

#include <stdio.h>
#include <stdlib.h>

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 sommes le calcul de la distance entre la ligne actuelle et celle du milieu, nous avons besoin de connaître la valeur absolue. abs fonction de série C de la fonction pour le faire.

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

Le nombre d'entrée sera la largeur du diamant, alors assurez-vous de faire une relation entre les espaces et les astérisques et ne pas dépasser ce nombre.

L'idée principale serait de commencer à 1 astérisque, et d'incrément par deux à chaque fois jusqu'à ce que le nombre d'entrée est atteint.

Aussi, faire quelque chose pour éviter une erreur si l'utilisateur entre un nombre pair.

 static void Main(string[] 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<stdio.h>
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");
}
}

La sortie d'un diamant en C par un astérisque signe

#include<stdio.h>
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<i-1; j++)
{
printf(" ");
}
/* Right side. */
for(j=1; j<i; j++)
{
printf(" ");
}
for(j=1; j<=1; j++)
{
if(i!=n-(n-1))
printf("*");
}
printf("\n");
}
/* Create down arrow. */
for(i=1; i<=n; i++)
{   /* Left side. */
for(j=1; j<=i+2; j++)
{
printf(" ");
}
for(j=1; j<=1; j++)
{
if(i!=n)
printf("*");
}
/* Middle. */
for(j=i; j<n-2; j++)
{
printf(" ");
}
/* Right side. */
for(j=i; j<n-1; j++)
{
printf(" ");
}
for(j=1; j<=1; j++)
{
if(i<n-1)
printf("*");
}
printf("\n");
}
}