Hari ini, kita akan membuat segi enam ASCII. Anda harus menulis sebuah program atau fungsi yang mengambil bilangan bulat positif n , dan menampilkan kisi segi enam ukuran n , yang terdiri dari tanda bintang. Misalnya, segi enam ukuran 2 terlihat seperti ini:

 * *
* * *
 * *

Sementara segi enam ukuran 3 terlihat seperti ini:

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

Anda dapat menggunakan salah satu dari metode input dan output default , misalnya STDIO / STDOUT, argumen fungsi dan mengembalikan nilai atau membaca / menulis file.

Anda dapat berasumsi bahwa input selalu valid, jadi jika itu bukan bilangan bulat positif, program Anda dapat melakukan apa pun yang Anda inginkan. Anda jangan Namun harus menangani kasus khusus dari ukuran 1 segi enam, yang terjadi menjadi tanda bintang tunggal:

*

Ruang putih terkemuka dan trailing diizinkan selama output secara visual sama.

Contoh:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Seperti biasa, ini adalah kode-golf , sehingga celah standar berlaku , dan Anda harus mencoba menulis program sesingkat mungkin yang diukur dalam byte. Tentu saja, beberapa bahasa secara inheren lebih pendek atau lebih lama dari yang lain, jadi ingatlah bahwa tujuannya tidak harus memiliki jumlah byte keseluruhan terpendek, tetapi untuk mengalahkan pengiriman dalam bahasa yang sama atau mirip.

Semoga pegolf terbaik menang!

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

Termasuk +3 untuk -gflag dan +8 untuk |tr . \*doa non-standar (lihat posting meta ini )

Input diberikan sebagai argumen untuk Hexagony. Ketika interpreter Hexagony dipanggil dengan -g Nopsi itu mencetak hexagon dari .s. Kami kemudian menggunakan tr untuk menggantikannya dengan *s.

Python 2, 61 byte

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

Mencetak spasi tambahan di akhir setiap baris.

Terima kasih kepada Erik, Outgolfer karena telah menghemat satu byte.

JavaScript (ES6), 77 81 84

@Upvoters: jangan lewatkan jawaban oleh @ETHproductions, yaitu 76 byte

Sunting Direvisi setelah perubahan spesifikasi, spasi tambahan diizinkan

Hanya untuk topinya ... hei! Tanpa topi?

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

Uji

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 byte

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

Cobalah online!

Akhirnya berhasil.

Awalnya (sebelum menyadari betapa mahal loop), saya berharap ini bisa masuk dalam panjang sisi 5, tapi sekarang cukup sulit untuk memasukkannya ke dalam panjang sisi 6.

Untuk mendapatkan ini saya sebenarnya harus memodifikasi kode linear sedikit. Bahkan, menulis ini membuat saya menyadari cara untuk menurunkan kode linear dengan 1 2 byte.

JavaScript (ES6), 77 76 byte

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

Saya berkata pada diri saya sendiri bahwa saya tidak akan tidur sampai saya membuat rekor ES6 baru tanpa melihat jawaban yang lain, jadi ini dia ...

Cuplikan tes

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 byte

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

Saya cukup banyak tweak untuk mendapatkan formula yang benar, lalu tumbuk semuanya.

Panggil fdengan nomor n , dan itu akan mencetak segi enam ke stdout.

Tidak digabungkan dan dijelaskan (versi 80-byte):

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
}

Lihat langsung di Coliru

Catatan:

• printfdapat menangani padding negatif, yang menghasilkan karakter rata kiri dengan padding di sebelah kanan. Jadi saya mencoba sesuatu untuk efek w = printf("%*c*", y, ' ')sehingga akan menjaga nilai absolut, dan saya bisa mengambilnya dari nilai pengembaliannya. Sayangnya, lebar nol dan satu padding mencetak karakternya sendiri, sehingga tiga garis tengahnya identik.
  Pembaruan: Jasen telah menemukan cara untuk melakukan hal ini dengan mencetak string kosong alih-alih karakter - 6 byte dicukur habis!

• Karakter backspace ditangani secara tidak benar oleh Coliru - mengeksekusi kode ini pada terminal lokal tidak menghilangkan ruang terdepan di setiap baris.

05AB1E , 14 13 byte

Kode:

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

Penjelasan:

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

Menggunakan pengkodean CP-1252 . Cobalah online!

Jelly , 24 byte

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

Cobalah online!

Jelly malu karena fakta bahwa ia tidak memiliki atom sentralisasi, sehingga dipukuli oleh 05AB1E dan V. Masing-masing dengan 11 dan 7 byte!

Jika Anda menemukan cara untuk bermain golf ini, silakan komentar. Bantuan apa pun dihargai.

Penjelasan :

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.

Bonus: Untuk menemukan berapa banyak bintang yang ada di segi enam, gunakan ini:

Ḷ×6S‘

Oktaf, 62 58 byte

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

Jawaban sebelumnya:

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

yang bisa disebut sebagai

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

Coba (tempel) di Octave Online

Misalnya gambar dasar untuk n=5is

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

yang dapat dibuat dengan

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

The dilation morphological operatorditerapkan 4 kali pada gambar menggunakan tetangga masker berikut:

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

yang dapat dibuat dengan [k='01010'-48;~k;k]

hasil pelebaran:

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

lalu ganti 0 dan 1 masing-masing dengan '' dan '*'

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

postgresql9.6, 290 byte

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 yang diformat ada di sini:

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;
$$;

keluaran:

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

V , 17 byte

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

Cobalah online!

Seperti biasa, ini hexdump, karena ini berisi karakter yang tidak patut:

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

APL (Dyalog Unicode) , 40 36 35 33 27 25 byte

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

Asumsikan ⎕IO←0, yaitu pengindeksan berbasis nol. Output berisi satu spasi awal dan satu spasi tambahan di setiap baris.

Banyak terima kasih kepada @FrownyFrog dan @ngn untuk banyak bermain golf.

Cobalah online!

Bagaimana itu bekerja

(⍉⊖⍪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 byte

Ini adalah jawaban (golf kode) pertama saya. Saya harap saya memformat semuanya dengan benar.

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

Tidak seperti 2 jawaban ES6 saat ini, saya tidak secara rekursif memanggil fungsi dan saya menggunakan konsol untuk output.

Haskell, 99 97 79 byte

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

Penjelasan: Program ini didasarkan pada pengamatan bahwa setiap baris n-Hexagon berisi (nk) spasi diikuti oleh tanda bintang (n + k-1), untuk beberapa k tergantung pada nomor baris.

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 

Edit: Beralih ke mapM_. Saya tidak tahu itu tersedia tanpa menggunakan impor

Python 2 , 100 97 89 88 87 81 79 byte

-1 dari @ Flp.Tkc

-6 lagi dari @Flp

-2 dengan terima kasih kepada @ nedla2004. Saya mencoba menemukan cara untuk menyingkirkan potongan kedua tetapi tidak memikirkan yang itu :)

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

Cobalah online!

Membuat array untuk bagian atas kemudian menambahkan array yang dibalik minus garis tengah kemudian mencetak. Mencetak dengan tepat "apa adanya" selain dari 1yang mencetak dengan ruang terdepan (saya kira itu diperbolehkan karena secara *visual sama dengan *dengan atau tanpa ruang terdepan).

Batch, 161 byte

@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%%

Catatan: Trailing space pada baris 2. Tidak dikumpulkan:

@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 byte

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>

Kanvas , 9 byte

╷⁸＋* ×］／─

Coba di sini!

Mengalahkan built-in: D

Penjelasan:

{╷⁸+* ×]/─  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

_{Tidak tahu mengapa ada padding besar, tapi itu diperbolehkan & saya segera memperbaikinya ™. tetap? Semoga saya tidak merusak barang-barang}

Perl 6 , 49 byte

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

Cobalah online!

Bagaimana itu bekerja

->\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 byte

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

Skrip uji:

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

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

Output (ruang memimpin tambahan):

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

Penjelasan:

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 byte

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

Jalankan sebagai pipa dengan -nRatau coba online .

Ini dekat dengan jawaban Kodos ; tetapi str_padlebih pendek daripada str_repeatsaat golf.
Dan ++di kepala loop menyimpan lebih banyak.

Ruby, 54 byte

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

fungsi lambda mengambil n sebagai argumen dan mengembalikan string yang dipisahkan oleh baris baru. ( $/adalah variabel yang mengandung pemisah garis default.)

dalam program uji

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

puts f[gets.to_i]

Charly, 125 byte

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}

Halaman Charly GitHub: https://github.com/KCreate/charly-lang

SmileBASIC, 74 byte

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

Menambahkan ruang awal dan akhir.

"Segi enam" ini terlihat mengerikan ketika karakter memiliki lebar dan tinggi yang sama ...

raket / skema

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

pengujian:

(f 1)
*

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

Python 2, 111 byte

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

Implementasi yang membosankan dan langsung (dan program lengkap). Output spasi spasi di setiap baris.

Testcases:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 byte

Akhirnya liburan Natal (selamat Natal!), Jadi saya punya waktu untuk bermain golf.
Dan nak sudah lama - maka jumlah byte yang besar.
Ini dia:

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 byte

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 byte dihapus oleh Jonathan Frech.
• 20 byte dihapus oleh Kevin Cruijssen.
• 2 byte dihapus oleh Kevin Cruijssen.

Cobalah online!

Hexagony (linear), 128 127 126 byte

Perhatikan bahwa ini bukan Hexagony, hanya bahasa Timwi (meta) yang didukung dalam Esoteric IDE, jadi ini tidak memenuhi syarat untuk hadiah.

Namun ini dapat dikonversi menjadi solusi Hexagony (dan saya pikir ini akan lebih kecil dari solusi ini) saya dapat melakukannya nanti. Dibutuhkan lebih banyak usaha yang saya lakukan di sini .

Awal ❢membutuhkan 3 byte ( e2 9d a2). Setiap baris baru membutuhkan 1 byte ( 0a).

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

Tidak, Coba online !. Ini hanya berfungsi di IDE Esoterik.

Kode beranotasi:

❢?        # 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 byte

Æ°çSi*Ãû ê

Cobalah (atau gunakan TIO untuk menjalankan beberapa tes)

Penjelasan

               :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