包括

Question

我正试图解决这个模式，用户的输入是星的最大长度.. 例如

enter image description here
图像用于输入11和12

其他模式示例

（9）1-5-9-5-9-5-1
（11）1-5-9-11-9-11-9-5-1
（12）2-6-10-12-10-12-10-6-2
（16）2-6-10-14-16-14-10-14-16-14-10-6-2

如果数字是奇数，则恒星从1开始，每行增加4，但当增量变得大于最大长度时，只增加2 ..如果数字是偶数，则恒星从2开始但是遵循相同的递增方式。

所以，我试图做的是首先在上面部分工作然后再镜像它，这里是我的代码FOR ODD数字，计划在这之后使用偶数数字

#include <stdio.h>

int main(){
    int stars, spaces, maxlen, rows;
    int spac=0, star=1;
    scanf("%d", &maxlen);

    for (rows=1;rows<=maxlen;rows++){
        for(spaces=1; spaces<=(maxlen/2)-spac; spaces++){
            printf(" ");
        }

        for(stars=1; stars<=star; stars++){
            printf("*");
        }

        printf("\n");

        if (star>=maxlen)
            break;

        if (star==9)
            star += 2;
        else
            star += 4;

        spac+=2;
    }

    return 0;
}

该代码适用于1,9,11，但是当我从13+输入时它的问题并没有给我预期的结果...

Anyhelp我怎么能解决这个问题，我会欣赏对我的方法的评论，这是一个好的方法还是有另一种方法来解决我应该学习的模式，更容易解决这种不规则的模式？

Answer 1

当我看到图案时，有两个重叠的*符号正方形，带有修剪边缘，它们会溢出线条长度（最长的线条只比前一条线条多两个*）第二件事是它不确定，这两个方格有多远。

我写了这样的话：

#include <stdio.h>

#define OVERLAPP 1

int linesCount(int maxlen)
{
    return maxlen + maxlen%2 + (OVERLAPP);
}

int get_stars(int maxlen, int line)
{
    if (2 * line > linesCount(maxlen))
    {
       return get_stars(maxlen, linesCount(maxlen) - line - 1);
    }
    else
    {
        int stars;
        stars = 2 - maxlen%2;
        stars += 4 * line;
        if (stars > maxlen)
        {
            if (stars - maxlen < 3)
            {
                stars = maxlen;
            }
            else
            {
                stars = 2 * maxlen - stars + 4;
            }
        }
        return stars;
    }
}

int main(int argc, char **argv)
{
    int maxlen;
    int maxlines;
    int line;
    int column;
    int current_stars;

    scanf("%d", &maxlen);
    maxlines = linesCount(maxlen);

    for(line = 0; line < maxlines; line++)
    {
        current_stars = get_stars(maxlen, line);
        for(column = 0; 2 * column + 1 < maxlen - current_stars; column++)
        {
            printf(" ");
        }
        for(column = 0; column < current_stars; column++)
        {
            printf("*");
        }
        for(column = 0; 2 * column + 1 < maxlen - current_stars; column++)
        {
            printf(" ");
        }
        printf(" %d\n", current_stars);
    }

}

这给出了以下结果：

gcc golf.c; seq 20 | xargs -I num echo "echo;echo "--------num---------";echo; echo num | ./a.exe" | bash

--------1---------

* 1
* 1
* 1

--------2---------

** 2
** 2
** 2

--------3---------

 *  1
*** 3
 *  1
*** 3
 *  1

--------4---------

 **  2
**** 4
 **  2
**** 4
 **  2

--------5---------

  *   1
***** 5
***** 5
  *   1
***** 5
***** 5
  *   1

--------6---------

  **   2
****** 6
****** 6
  **   2
****** 6
****** 6
  **   2

--------7---------

   *    1
 *****  5
******* 7
 *****  5
   *    1
 *****  5
******* 7
 *****  5
   *    1

--------8---------

   **    2
 ******  6
******** 8
 ******  6
   **    2
 ******  6
******** 8
 ******  6
   **    2

--------9---------

    *     1
  *****   5
********* 9
********* 9
  *****   5
    *     1
  *****   5
********* 9
********* 9
  *****   5
    *     1

--------10---------

    **     2
  ******   6
********** 10
********** 10
  ******   6
    **     2
  ******   6
********** 10
********** 10
  ******   6
    **     2

--------11---------

     *      1
   *****    5
 *********  9
*********** 11
 *********  9
   *****    5
     *      1
   *****    5
 *********  9
*********** 11
 *********  9
   *****    5
     *      1

--------12---------

     **      2
   ******    6
 **********  10
************ 12
 **********  10
   ******    6
     **      2
   ******    6
 **********  10
************ 12
 **********  10
   ******    6
     **      2

--------13---------

      *       1
    *****     5
  *********   9
************* 13
************* 13
  *********   9
    *****     5
      *       1
    *****     5
  *********   9
************* 13
************* 13
  *********   9
    *****     5
      *       1

--------14---------

      **       2
    ******     6
  **********   10
************** 14
************** 14
  **********   10
    ******     6
      **       2
    ******     6
  **********   10
************** 14
************** 14
  **********   10
    ******     6
      **       2

--------15---------

       *        1
     *****      5
   *********    9
 *************  13
*************** 15
 *************  13
   *********    9
     *****      5
       *        1
     *****      5
   *********    9
 *************  13
*************** 15
 *************  13
   *********    9
     *****      5
       *        1

--------16---------

       **        2
     ******      6
   **********    10
 **************  14
**************** 16
 **************  14
   **********    10
     ******      6
       **        2
     ******      6
   **********    10
 **************  14
**************** 16
 **************  14
   **********    10
     ******      6
       **        2

--------17---------

        *         1
      *****       5
    *********     9
  *************   13
***************** 17
***************** 17
  *************   13
    *********     9
      *****       5
        *         1
      *****       5
    *********     9
  *************   13
***************** 17
***************** 17
  *************   13
    *********     9
      *****       5
        *         1

--------18---------

        **         2
      ******       6
    **********     10
  **************   14
****************** 18
****************** 18
  **************   14
    **********     10
      ******       6
        **         2
      ******       6
    **********     10
  **************   14
****************** 18
****************** 18
  **************   14
    **********     10
      ******       6
        **         2

--------19---------

         *          1
       *****        5
     *********      9
   *************    13
 *****************  17
******************* 19
 *****************  17
   *************    13
     *********      9
       *****        5
         *          1
       *****        5
     *********      9
   *************    13
 *****************  17
******************* 19
 *****************  17
   *************    13
     *********      9
       *****        5
         *          1

--------20---------

         **          2
       ******        6
     **********      10
   **************    14
 ******************  18
******************** 20
 ******************  18
   **************    14
     **********      10
       ******        6
         **          2
       ******        6
     **********      10
   **************    14
 ******************  18
******************** 20
 ******************  18
   **************    14
     **********      10
       ******        6
         **          2

Answer 2

我认为这是在很多方面划分问题的更好方法。例如

以一行和最大宽度绘制开始次数然后绘制一行开始的函数
```
void draw_line_of_stars(unsigned int stars, unsigned int max_width)
```
获取行并返回绘制开始数的函数
```
unsigned int get_n_stars(unsigned int line, unsigned int starsize)
```
- 这个函数可能是由更多函数组装来处理对称性的，例如
使用这两个函数绘制整星的功能。

我建议使用这种方法，因为您可以单独测试每个函数以检查它是否正常工作，然后在这个更复杂的解决方案中组装它们。

Answer 3

哇我以为这是不可能的。我有一个代码为2,4,2,4,2。

包括

int main(void) {
    int i, j;
    int NumMax = 5;
    for(i = 0; i < NumMax; i++)
    {
        if((i%2) == 0)
        {
            printf(" ");
            for(j = 0; j < 2; j++)
            {
                printf("*");
            }
        }
        else
        {
            for(j = 0; j < 4; j++)
            {
                printf("*");
            }
        }
        printf("\n");
    }

    return 0;

Answer 4

另一个人不想编辑我所谓的答案，但是在for循环中的模式1,6,6,1,6,6,1，打印6的行的外部是30的倍数。这是代码，并希望有人称之为愚蠢。

#include <stdio.h>

int main(void)
{
    int i, j, m, k;
    int numMax = 6;

    for(i = 1; i < (numMax * 2) - 4; i++)
    {
        if(((30 % i) == 0) && (i != 1))
        {
            for(k = 1; k < 2; k++)
            {
                for(m = 1; m <= numMax; m++)
                {
                     printf("*");
                }
                printf("\n");
            }
        }
        else
        {
            for(j = 1; j < 2; j++)
            {
                printf("  **");
            }
            printf("\n");
        }
    }

    return 0;
}

C中的星形图案

4 个答案:

包括