วันนี้เราจะสร้างรูปหกเหลี่ยม ASCII คุณต้องเขียนโปรแกรมหรือฟังก์ชั่นที่ใช้จำนวนเต็มบวกnและส่งออกกริดหกเหลี่ยมที่มีขนาดnประกอบด้วยเครื่องหมายดอกจัน ตัวอย่างเช่นรูปหกเหลี่ยมของขนาด 2 มีลักษณะดังนี้:

 * *
* * *
 * *

ในขณะที่รูปหกเหลี่ยมของขนาด 3 มีลักษณะดังนี้:

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

คุณสามารถใช้วิธีการอินพุตและเอาต์พุตเริ่มต้นตัวอย่างเช่น STDIO / STDOUT อาร์กิวเมนต์ของฟังก์ชันและค่าส่งคืนหรืออ่าน / เขียนไฟล์

คุณอาจสมมติว่าอินพุตนั้นถูกต้องเสมอดังนั้นหากไม่ใช่จำนวนเต็มบวกโปรแกรมของคุณอาจทำทุกอย่างที่คุณต้องการ คุณไม่แต่มีการจัดการกรณีพิเศษของหกเหลี่ยมขนาด 1 ซึ่งเกิดขึ้นเป็นเครื่องหมายดอกจันเดียว:

*

ช่องว่างนำหน้าและต่อท้ายได้รับอนุญาตตราบใดที่เอาต์พุตเหมือนกัน

ตัวอย่าง:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

ตามปกตินี่คือโค้ดกอล์ฟดังนั้นจึงมีช่องโหว่มาตรฐานและคุณควรพยายามเขียนโปรแกรมที่สั้นที่สุดที่เป็นไปได้ที่วัดเป็นไบต์ แน่นอนว่าบางภาษามีความสั้นกว่าหรือยาวกว่าคนอื่นดังนั้นโปรดจำไว้ว่าเป้าหมายไม่จำเป็นต้องมีจำนวนไบต์ที่สั้นที่สุดโดยรวม แต่ต้องเอาชนะการส่งในภาษาเดียวกันหรือคล้ายกัน

ขอให้นักกอล์ฟที่ดีที่สุดชนะ!

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 Bytes

รวม +3 สำหรับการ-gตั้งค่าสถานะและ +8 สำหรับการเรียกที่|tr . \*ไม่ได้มาตรฐาน (ดูโพสต์เมตานี้)

อินพุตได้รับเป็นอาร์กิวเมนต์สำหรับ Hexagony เมื่อล่าม Hexagony ถูกเรียกพร้อมกับ-g Nตัวเลือกมันจะพิมพ์หกเหลี่ยมของ.s จากนั้นเราใช้ tr เพื่อแทนที่ด้วย*s

Python 2, 61 ไบต์

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

พิมพ์ช่องว่างท้ายท้ายแต่ละบรรทัด

ขอบคุณ Erik the Outgolfer ที่บันทึกไบต์

JavaScript (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>

Hexagony , 91 87 86 ไบต์

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

ลองออนไลน์!

ในที่สุดก็ทำ

เริ่มแรก (ก่อนที่จะทราบว่าลูปมีราคาแพง) ฉันคาดว่าสิ่งนี้อาจจะพอดีกับความยาวด้าน 5 แต่ตอนนี้มันยากพอที่จะใส่ลงในความยาวด้าน 6

เพื่อให้ได้สิ่งนี้ฉันต้องแก้ไขรหัสเชิงเส้นเล็กน้อย ในความเป็นจริงการเขียนสิ่งนี้ทำให้ฉันตระหนักถึงวิธีการเขียนรหัสเชิงเส้นลง1 2 ไบต์

JavaScript (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และมันจะพิมพ์รูปหกเหลี่ยมไปที่ stdout

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
}

ดูมันสดบน Coliru

หมายเหตุ:

• printfสามารถจัดการกับช่องว่างภายในเชิงลบซึ่งส่งผลให้อักขระที่จัดชิดซ้ายด้วยช่องว่างด้านขวา ดังนั้นฉันจึงลองทำบางอย่างเพื่อผลของw = printf("%*c*", y, ' ')มันดังนั้นมันจะดูแลค่าสัมบูรณ์และฉันสามารถดึงมันกลับมาจากมูลค่าที่ส่งคืนได้ น่าเสียดายที่ทั้งความกว้างเป็นศูนย์และความกว้างการเว้นหนึ่งจุดจะพิมพ์อักขระด้วยตัวเองดังนั้นเส้นกึ่งกลางสามเส้นจึงเหมือนกัน
  อัปเดต: Jasenพบวิธีที่จะทำสิ่งนี้ได้อย่างแน่นอนโดยการพิมพ์สตริงที่ว่างเปล่าแทนตัวอักษร - 6 ไบต์ถูกลบทิ้ง!

• อักขระ Backspace ได้รับการจัดการอย่างไม่ถูกต้องโดย 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 62ไบต์

@(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 *Î.

ลองออนไลน์!

ตามปกตินี่คือ hexdump เนื่องจากมีอักขระที่ไม่สามารถพิมพ์ได้:

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←0คือการทำดัชนีแบบ zero-based เอาต์พุตมีหนึ่งช่องว่างนำหน้าและต่อท้ายหนึ่งช่องในแต่ละบรรทัด

ขอขอบคุณ @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

JavaScript (ES6), 83 81 ไบต์

นี่คือคำตอบแรกของฉัน (code golf) ฉันหวังว่าฉันจะจัดรูปแบบทุกอย่างถูกต้อง

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

ซึ่งแตกต่างจากคำตอบ ES6 ปัจจุบัน 2 ฉันไม่ได้เรียกฟังก์ชันซ้ำและฉันใช้คอนโซลสำหรับการส่งออก

Haskell, 99 97 79 ไบต์

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

คำอธิบาย: โปรแกรมนี้ขึ้นอยู่กับการสังเกตว่าแต่ละบรรทัดของ n-Hexagon มีช่องว่าง (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_ ฉันไม่ทราบว่ามีให้โดยไม่ใช้การนำเข้า

Python 2 , 100 97 89 88 87 81 79 79 ไบต์

-1 จาก @ Flp.Tkc

-6 อีกครั้งจาก @Flp

-2 ด้วยขอบคุณ @ nedla2004 ฉันพยายามหาวิธีกำจัดชิ้นที่สอง แต่ไม่ได้คิดอย่างนั้น :)

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

ลองออนไลน์!

สร้างอาร์เรย์สำหรับครึ่งบนแล้วเพิ่มอาร์เรย์กลับด้านลบด้วยเส้นตรงกลางจากนั้นพิมพ์ พิมพ์ว่า "ตามที่เป็น" นอกเหนือจากการ1พิมพ์ที่มีช่องว่างนำหน้า (ฉันเดาว่าได้รับอนุญาตให้เป็น a เหมือนกับ*ภาพที่*มีหรือไม่มีช่องว่างนำหน้า)

แบตช์ 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 Ungolfed:

@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

JavaScript (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>

Canvas ขนาด 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

_{ไม่รู้เลยว่าทำไมมันถึงมีช่องว่างขนาดใหญ่ แต่มันได้รับอนุญาต & ฉันกำลังแก้ไขมันในไม่ช้า™ แก้ไขแล้ว? หวังว่าฉันจะไม่ทำลายข้าวของ}

Perl 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_repeatแม้ตอนตีกอล์ฟ
และ++ในส่วนหัวของลูปจะช่วยได้มากขึ้น

Ruby, 54 ไบต์

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

ฟังก์ชั่นแลมบ์ดารับ 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)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

Python 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:]

การใช้งานที่น่าเบื่อตรงไปตรงมา (และโปรแกรมเต็มรูปแบบ) เอาต์พุตช่องว่างต่อท้ายที่แต่ละบรรทัด

Testcases:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (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));

Java, 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);}

• ลบแล้ว 8 ไบต์โดย Jonathan Frech
• นำออกโดย Kevin Cruijssen 20 ไบต์
• 2 bytes ถูกลบโดย Kevin Cruijssen

ลองออนไลน์!

Hexagony (เชิงเส้น), 128 127 126 ไบต์

โปรดทราบว่านี่ไม่ใช่ Hexagony เป็นเพียงภาษา (meta-) Timwi ที่สนับสนุนใน Esoteric IDE ดังนั้นจึงไม่มีสิทธิ์รับรางวัล

อย่างไรก็ตามสิ่งนี้สามารถแปลงเป็นโซลูชัน 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