오늘, 우리는 ASCII 육각형을 만들 것입니다. 양의 정수 n 을 취하고 별표로 구성된 크기 n 의 육각 격자를 출력 하는 프로그램 또는 함수를 작성해야합니다 . 예를 들어 크기가 2 인 육각형은 다음과 같습니다.

 * *
* * *
 * *

크기 3의 육각형은 다음과 같습니다.

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

STDIO / STDOUT, 함수 인수 및 반환 값 또는 파일 읽기 / 쓰기 와 같은 기본 입력 및 출력 방법을 사용할 수 있습니다 .

입력이 항상 유효하다고 가정 할 수 있으므로 양의 정수가 아닌 경우 프로그램은 원하는 모든 작업을 수행 할 수 있습니다. 당신은 않습니다 그러나 하나의 별표 될 일이 크기 1 육각형의 특별한 경우를 처리 할 수있다 :

*

출력이 시각적으로 동일한 한 선행 및 후행 공백이 허용됩니다.

예 :

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

평소와 같이 이것은 code-golf 이므로 표준 허점이 적용 되므로 가능한 가장 짧은 프로그램을 바이트 단위로 작성해야합니다. 물론 일부 언어는 기본적으로 다른 언어보다 짧거나 길기 때문에 전체 바이트 수가 가장 짧을 필요는 없지만 동일하거나 유사한 언어로 제출을이기는 것이 목표라는 점을 기억하십시오.

최고의 골퍼가 이길 수 있습니다!

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 바이트

-g플래그는 +3, |tr . \*비표준 호출은 +8 포함 (이 메타 포스트 참조 )

입력은 Hexagony에 대한 인수로 제공됩니다. -g N옵션으로 Hexagony 인터프리터를 호출하면 .s 의 육각형이 인쇄 됩니다. 그런 다음 tr을 사용하여 *s 로 대체합니다 .

파이썬 2, 61 바이트

i=n=input()
while~-n+i:i-=1;j=abs(i);print' '*j+'* '*(2*n+~j)

각 줄의 끝에 후행 공백을 인쇄합니다.

바이트를 절약 해 준 Outgolfer Erik에게 감사합니다.

자바 스크립트 (ES6), 77 81 84

@Upvoters : @ETHproductions의 답을 놓치지 마십시오 .76 바이트입니다.

편집 사양의 변경 후 수정, 공간 후행 허용

모자 만 ... 이봐! 모자가 없습니까?

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o

테스트

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o


function update()
{
  O.textContent=f(+I.value)
}

update()

<input id=I type=number min=1 value=3 oninput='update()'>
<pre id=O></pre>

헥사 고니 , 91 87 86 바이트

?{2'*=&~}=&}='P0</0P}|@..;>;'.\};0Q/..\&(<>"-_"&}=\?_&\/8.=-\<><;{M/.(.(/.-{><.{&'/_.\

온라인으로 사용해보십시오!

마침내 해냈습니다.

처음에 (루프가 얼마나 비싸다는 것을 깨닫기 전에) 이것이 측면 길이 5에 맞을 수 있다고 기대하지만 이제는 측면 길이 6에 맞추기에 충분하지 않습니다.

이것을 얻으려면 실제로 선형 코드를 약간 수정해야합니다. 실제로 이것을 작성하면 선형 코드를 1 2 바이트 씩 줄이려고 할 수 있습니다.

자바 스크립트 (ES6), 77 76 바이트

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

나는 다른 답변을 보지 않고 새로운 ES6 레코드를 설정할 때까지 잠을 자지 않을 것이라고 스스로에게 말했다.

테스트 스 니펫

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

for(var i = 1; i < 7; i++) console.log(g(i)) // joe

C, 91 89 80 74 바이트

w,y;f(s){for(y=-s;++y<s;)for(w=printf("\n%*s",y,"");++w<s*printf(" *"););}

나는 올바른 공식을 얻기 위해 주위를 많이 조정 한 다음 모두 함께 으깬다.

f숫자 n을 호출 하면 육각형이 표준 출력으로 인쇄됩니다.

Ungolfed 및 설명 (80 바이트 버전) :

w,y;
f(s) {
    // y iterates over [-s + 1 ; s - 1] (the number of rows)
    for(y = -s; ++y < s;)
        // w iterates over [abs(y) + 2 ; s * 2 - 1] (the number of stars on the row)
        for(
            // This prints a backspace character (ASCII 8)
            // padded with abs(y) + 2 spaces, effectively
            // printing abs(y) spaces to offset the row.
            // Also initializes w with abs(y) + 2.
            printf("\n%*c", w = abs(y) + 2, 8);

            // This is the for's condition. Makes use
            // of the 2 returned by printf, since we coïncidentally
            // need to double the upper bound for w.
            w++ < s * printf("* ");

            // Empty for increment
        )
            ; // Empty for body
}

콜리 루에서 생방송보기

노트:

• printf네거티브 패딩을 처리 할 수 ​​있으며, 그 결과 오른쪽에 패딩이있는 왼쪽 정렬 문자가 생성됩니다. 따라서 나는 그 효과에 무언가를 시도 w = printf("%*c*", y, ' ')하여 절대 값을 처리하고 반환 값에서 검색 할 수있었습니다. 불행하게도, 0과 1의 패딩 너비 모두 문자를 자체적으로 인쇄하므로 3 개의 중심선이 동일합니다.
  업데이트 : Jasen 은 문자 대신 빈 문자열을 인쇄 하여이 작업을 정확하게 수행하는 방법을 찾았습니다-6 바이트가 줄었습니다!

• Coliru에서 백 스페이스 문자를 잘못 처리합니다. 로컬 터미널에서이 코드를 실행하면 각 행의 선행 공백이 제거됩니다.

05AB1E , 14 13 바이트

암호:

F¹N+„ *×})û.c

설명:

F       }        # Input times do (N = iteration number)
 ¹N+             #   Calculate input + N
    „ *×         #   Multiply by the string " *"
         )       # Wrap everything into an array
          û      # Palindromize the array
           .c    # Centralize

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

젤리 , 24 바이트

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY

온라인으로 사용해보십시오!

젤리는 중앙 집중화 원자가 없기 때문에 부끄러워서 05AB1E와 V에 이겼습니다. 각각 11 바이트와 7 바이트!

골프를 치는 방법을 찾으면 의견을 말하십시오. 도움을 주시면 감사하겠습니다.

설명 :

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY Main link. Arguments: z.
R+’                      The sizes of the hexagon's rows. (implicit argument)
   µ                     Start a new monadic chain with the above argument.
    ȧṀx@€⁶               The spaces you must prepend to each row. (implicit argument)
           x@K¥€”*$      The stars (points) of each row, space-joined, as a single link. (implicit argument)
          ż        F€    Conjoin and merge the leading spaces with the stars appropriately.
                     ŒḄ  Create the second half of the hexagon without the middle row.
                       Y Join the rows with newlines. This makes the shape look like a hexagon.

보너스 : 육각형에 별이 몇 개 있는지 찾으려면 다음을 사용하십시오.

Ḷ×6S‘

옥타브, 62 58 바이트

@(n)' *'(dilate(impad(1,2*--n,n),[k='01010'-48;~k;k],n)+1)

이전 답변 :

@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1)

로 불릴 수있는

(@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1))(5)

Octave Online 에서 사용해보십시오 (붙여 넣기).

예를 들어 기본 이미지 n=5는

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

그것으로 만들 수 있습니다

impad(1,2*(n-1),n-1)

dilation morphological operator다음 인접 마스크를 이용하여 이미지에 4 번인가 :

0 1 0 1 0
1 0 1 0 1
0 1 0 1 0

그것으로 만들 수 있습니다 [k='01010'-48;~k;k]

팽창의 결과 :

0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0

그런 다음 0과 1을 각각 ''와 '*'로 바꿉니다.

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

postgresql9.6, 290 바이트

do language plpgsql $$ declare s constant smallint:=4;declare n smallint;declare a constant int[]:=array(select generate_series(1,s));begin foreach n in array a||array(select unnest(a)t order by t desc offset 1)loop raise info'%',concat(repeat(' ',s-n),repeat(' *',s+(n-1)));end loop;end;$$

형식이 지정된 SQL은 다음과 같습니다.

do language plpgsql $$
declare s constant smallint := 4;
declare n smallint;
declare a constant int[] := array(select generate_series(1, s));
begin
foreach n in array a || array(select unnest(a)t order by t desc offset 1) loop
    raise info '%', concat(repeat(' ', s - n), repeat(' *', s + (n - 1)));
end loop;
end;
$$;

산출:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *

V , 17 바이트

é*À­ñ>{MÄpXA *Î.

온라인으로 사용해보십시오!

평소와 같이, 여기에는 인쇄 할 수없는 문자가 포함되어 있으므로 16 진수 덤프가 있습니다.

00000000: e92a c0ad f13e 7b4d c470 5841 202a 1bce  .*...>{M.pXA *..
00000010: 2e                                       .

APL (Dyalog Unicode) , 40 36 35 33 27 25 바이트

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

⎕IO←00부터 시작하는 인덱싱을 가정 합니다. 출력에는 각 줄에 하나의 선행 및 후행 공백이 포함됩니다.

많은 골프를하신 @FrownyFrog와 @ngn에게 감사드립니다.

온라인으로 사용해보십시오!

작동 원리

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨  ⍝ Main function train
                 '* '⍴⍨+⍨  ⍝   Repeat '* ' up to length 2×⍵
            ⍳↓¨∘⊂          ⍝   Generate lower-right corner of the hexagon
          ∘↑               ⍝   Convert to matrix
(⍉⊖⍪1↓⊢)                   ⍝   Palindromize vertically and transpose
        ⍣2                 ⍝   ... twice

자바 스크립트 (ES6), 83 81 바이트

이것은 나의 첫 번째 (코드 골프) 답변입니다. 모든 것을 올바르게 포맷했으면 좋겠습니다.

a=>{for(b=c=2*a-1;c;)console.log(" ".repeat(d=Math.abs(a-c--))+"* ".repeat(b-d))}

2 개의 현재 ES6 답변과 달리, 재귀 적으로 함수를 호출하지 않고 출력을 위해 콘솔을 사용하고 있습니다.

하스켈, 99 97 79 바이트

h n=mapM_(putStrLn.(\k->([k..n]>>" ")++([2..n+k]>>"* ")))([1..n-1]++[n,n-1..1])

설명 :이 프로그램은 n- 헥사곤의 각 줄에 (nk) 공백이 있고 그 뒤에 (n + k-1) 별표가 있으며, 일부 k는 줄 번호에 따라 달라집니다.

h n=                                             h is a function of type Int -> IO ()
  mapM_                                          mapM_ executes a function returning 
                                                 monadic actions on all objects 
                                                 in a list, in order. Then it executes 
                                                 these actions, in order. For this code, it 
                                                 transforms each value in the list into a 
                                                 monadic action that prints 
                                                 the corresponding line

      (                                          the function consists of two components
        putStrLn                                 the second part is printing the result of 
                                                 the first part to stdout 

        .                                        concatenating both components

        (\k->                                    the first parts first prints (n-k) spaces 
                                                 and then (n+k-1) asterisks

          ([k..n]>>" ")                          create the list of the integers from 
                                                 k to n (That is actually one more entry
                                                 than necessary, but just results in a
                                                 leading whitespace per line, while
                                                 saving 2 bytes compared to [1..n-k]).
                                                 Then create a new list where 
                                                 each element of that first list is 
                                                 replaced with the string " " and 
                                                 concatenate that result into one string

          ++                                     concatenate both lists

          ([2..n+k]>>"* ")                       create the list of the integers 
                                                 from 2 to n+k (of length n+k-1). 
                                                 Then create a new list where each 
                                                 element of that first list is replaced 
                                                 with the string "* " and concatenate 
                                                 that result into one big string
        ) 

      )         
      ([1..n-1]++[n,n-1..1])                     the list simply goes from 1 to n and 
                                                 back, supplying the k 

편집 : mapM_으로 전환했습니다. 가져 오기를 사용하지 않고 사용할 수 있다는 것을 알지 못했습니다.

파이썬 2 , 100 97 89 88 87 81 79 바이트

@ Flp.Tkc에서 -1

@Flp에서 다시 -6

@ nedla2004 덕분에 -2. 두 번째 조각을 제거하는 방법을 찾으려고했지만 그 생각은하지 않았습니다. :)

i=input()
a=[" "*(i-x)+"* "*(i+x)for x in range(i)]
print'\n'.join(a+a[-2::-1])

온라인으로 사용해보십시오!

상단 절반에 대한 배열을 만든 다음 반전 된 배열에서 가운데 ​​줄을 뺀 다음 인쇄합니다. 1선행 공백으로 인쇄하는 것과는 별도로 정확하게 "있는 그대로"인쇄합니다 . 선행 공백 이 있거나없는 *시각적으로 동일 하다고 생각 *됩니다.

배치, 161 바이트

@echo off
set s=*
set l=for /l %%i in (2,1,%1)do call 
%l%set s= %%s%% *
%l%echo %%s%%&call set s=%%s:~1%% *
echo %s%
%l%set s= %%s:~0,-2%%&call echo %%s%%

참고 : 2 행의 후행 공간.

@echo off
set s=*
rem build up the leading spaces and stars for the first row
for /l %%i in (2,1,%1) do call :s
rem output the top half of the hexagon
for /l %%i in (2,1,%1) do call :t
rem middle (or only) row
echo %s%
rem output the bottom half of the hexagon
for /l %%i in (2,1,%1) do call :b
exit/b
:s
set s= %s% *
exit/b
:t
echo %s%
rem for the top half remove a space and add a star to each row
set s=%s:~1% *
exit/b
:b
rem for the bottom half add a space and remove a star from each row
set s= %s:~0,-2%
echo %s%
exit/b

자바 스크립트 (ES6), 83 바이트

f=
n=>[...Array(n+--n)].map((_,i,a)=>a.map((_,j)=>j<n-i|j<i-n?``:`*`).join` `).join`
`

<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

캔버스 , 9 바이트

╷⁸＋* ×］／─

여기 사용해보십시오!

내장 : D

설명:

{╷⁸+* ×]/─  implicit "{"
{      ]    map over 1..input
 ╷            decrement: 0..input-1
  ⁸+          add the input: input..(input*2-1)
    * ×       repeat "* " that many times
        /   diagonalify that - pad each line with 1 less space than the previous
         ─  palindromize vertically

_{왜 거대한 패딩이 있는지는 모르지만, 허용되며 곧 수정 될 것입니다 ™. 결정된? 내가 물건을 나누지 않았기를 바랍니다}

펄 6 , 49 바이트

->\n{say " "x n*2-1-$_~"*"xx$_ for n...n*2-1...n}

온라인으로 사용해보십시오!

작동 원리

->\n{                                           }  # Lambda accepting edge size (e.g. 3)
                               for n...n*2-1...n   # For each row-size (e.g. 3,4,5,4,3):
                       "*"xx$_                     # List of stars     (e.g. "*","*","*")
         " "x n*2-1-$_                             # Spaces to prepend (e.g. "  ")
                      ~                            # Concatenate.      (e.g. "  * * *")
     say                                           # Print

Powershell, 91 89 78 68 63 52 48 바이트

param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}

테스트 스크립트 :

$script = {
param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}
}

12,6,5,4,3,2,1 |%{
    $_
    . $script $_
}

출력 (추가 선행 공간) :

12
            * * * * * * * * * * * *
           * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
           * * * * * * * * * * * * *
            * * * * * * * * * * * *
6
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
 * * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
5
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
  * * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * *
4
    * * * *
   * * * * *
  * * * * * *
 * * * * * * *
  * * * * * *
   * * * * *
    * * * *
3
   * * *
  * * * *
 * * * * *
  * * * *
   * * *
2
  * *
 * * *
  * *
1
 *

설명:

param($n)           # define script parameter
$n..1+              # int range from n to 1 step -1; append
1..$n|              # int range from 1 to n
gu|                 # alias for Get-unique eliminates equal neighbors - here is 1,1 -> 1
%{                  # for each int from [n, n-1, n-2, ... 2, 1, 2, ... n-2, n-1, n]
    ' '*$_+         # string (' ' have repeated $_ times) append
    '* '*(2*$n-$_)  # string ('* ' have repeated 2*n-$_ times)
}

PHP, 83 79 바이트

for($p=str_pad;++$y<2*$n=$argn;)echo$p($p("
",1+$k=abs($n-$y)),4*$n-$k-2,"* ");

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

이것은 Kodos의 답변에 가깝습니다 . 하지만 str_pad보다 짧은 str_repeatgolfed 경우에도.
그리고 ++루프 헤드가 더 절약됩니다.

루비, 54 바이트

->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

lambda 함수는 n을 인수로 사용하고 개행으로 구분 된 문자열을 반환합니다. ( $/기본 줄 구분자를 포함하는 변수입니다.)

테스트 프로그램에서

f=->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

puts f[gets.to_i]

Charly, 125 바이트

let i="".promptn()let o=0let j=0let w=write loop{w(" "*(i-1-o),"* "*(i+o))w("
")if j<i-1{o+=1}else{o-=1}if o<0{break}j+=1}

Charly GitHub 페이지 : https://github.com/KCreate/charly-lang

SmileBASIC, 74 바이트

FOR I=0TO N-1P
NEXT
FOR I=N-2TO.STEP-1P
NEXT
DEF P?" "*(N-I);"* "*(N+I)END

선행 및 후행 공백을 추가합니다.

이 "육각형"은 문자의 너비와 높이가 같을 때 끔찍하게 보입니다 ...

라켓 / 구성표

(define (f n)
  (define (s t n)
    (if (= n 0) t (s (~a t "* ") (- n 1))))
  (define (h t p a i)
    (if (= i 0)
        (display t)
        (let ((x (~a t (make-string p #\space) (s "" a) "\n"))
              (q (if (> i n) (- p 1) (+ p 1)))
              (b (if (> i n) (+ a 1) (- a 1))))
          (h x q b (- i 1)))))
  (h "" (- n 1) n (- (* 2 n) 1)))

테스트 :

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

파이썬 2, 111 바이트

n=input()
l=range(n,2*n-1)
S=l+[2*n-1]+l[::-1]
W=range(1,n)
for w in W[::-1]+[0]+W:print" "*w+"* "*S[0];S=S[1:]

지루하고 간단한 구현 (및 전체 프로그램) 각 줄에 후행 공백을 출력합니다.

테스트 케이스 :

1:
*

2:
 * * 
* * * 
 * * 

3:
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 

4:
   * * * * 
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 

자바 스크립트 (ES6), 143 바이트

마침내 크리스마스 방학 (메리 크리스마스!) 이니 골프를 칠 시간이 있습니다.
그리고 소년은 오랜 시간이 지났으므로 큰 바이트 수입니다.
간다 :

c=[];a=a=>{for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}for(j=c.length-2;j>-1;j--)c.push(c[j]);return a==1?"*":c.join`\n`}
console.log(a(3));

자바 (157) 149 (129) 127 바이트

s->{for(int j=~--s,t;++j<=s;p(s-~s-t,"* "),p(1,"\n"))p(t=j<0?-j:j," ");};<T>void p(int j,T s){for(;j-->0;)System.out.print(s);}

• Jonathan Frech가 8 바이트를 제거했습니다.
• Kevin Cruijssen이 20 바이트를 제거했습니다.
• Kevin Cruijssen이 2 바이트를 제거했습니다.

온라인으로 사용해보십시오!

Hexagony (선형), 128 (127) 126 바이트

이것은 Hexagony 가 아니며 , Esoteric IDE에서 지원되는 (메타) 언어 Timwi이므로 현상금에 해당 되지 않습니다 .

그러나 이것은 Hexagony 솔루션으로 변환 될 수 있습니다 ( 그리고이 솔루션 보다 작을 것이라고 생각합니다). 내가 여기서 해낸 더 많은 노력이 필요 합니다 .

이니셜 ❢에는 3 바이트 ( e2 9d a2) 가 걸립니다 . 각 줄 바꿈에는 1 바이트 ( 0a) 가 걸립니다 .

❢?{2'*=(
A
if > 0
 "-"&}=&~}=&}=?&
 B
 if > 0
  }P0;'(
  goto B
 &{&'-{=-(
 C
 if > 0
  'P0;Q0;}(
  goto C
 {M8;{(
 goto A
@

온라인으로 사용해보십시오!. 이것은 단지 밀교 IDE에서 작동합니다.

주석이 달린 코드 :

❢?        # read input n
[n]
{2'*=(     # x = 2n-1
[x]
A
if > 0    # loop (x) from 2n-1 to 1
 "-      # a = x - n
 [a]
 "&}=&~}=&    # a = abs(a). Let K be this amount
 }=?&
 B
 if > 0       # print ' ' (a) times
  }P0;'(
  goto B
 &        # current cell = a (= K)
 {&       # a = n if K>0 else x
          # Note that K=abs(x-n). So if K==0 then x==n.
          # Therefore after this step a is always equal to n.
 '-{=-    # compute n-(K-n) = 2n+K
 (        # decrement, get 2n+K-1
 C
 if > 0   # print ' *' this many times
  'P0;Q0;}(
  goto C
 {M8;{    # print a newline, goto x
 (        # x -= 1
 goto A
@

Japt -R, 11 10 바이트

Æ°çSi*Ãû ê

시도해보십시오 (또는 TIO 를 사용 하여 여러 테스트를 실행하십시오)

설명

               :Implicit input of integer U
Æ              :Map the range [0,U)
 °             :  Postfix increment U
  ç            :  Repeat
   S           :    Space
    i*         :    Prepend asterisk
      Ã        :End map
       û       :Centre pad each string with spaces to the length of the longest string
         ê     :Palindromise
               :Implicitly join with newlines and output