Bugün bir ASCII altıgen oluşturacağız. Pozitif n tamsayısı alan ve yıldızlardan oluşan n boyutunda altıgen bir ızgara çıkaran bir program veya işlev yazmalısınız . Örneğin, boyutu 2 olan bir altıgen şuna benzer:

 * *
* * *
 * *

3 boyutunda bir altıgen şuna benzer:

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

Varsayılan giriş ve çıkış yöntemlerinden herhangi birini, örneğin STDIO / STDOUT, fonksiyon argümanları ve dönüş değerleri veya bir dosyayı okuma / yazma kullanabilirsiniz.

Girdinin her zaman geçerli olduğunu varsayabilir, bu nedenle pozitif bir tamsayı değilse, programınız istediğiniz şeyi yapabilir. Sen do ancak tek yıldız olur bir boyut 1 altıgen özel bir durumunu işlemek zorunda:

*

Çıktı görsel olarak aynı olduğu sürece öndeki ve takip eden boşluklara izin verilir.

Örnekler:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Her zaman olduğu gibi, bu kod golf , bu nedenle standart boşluklar geçerlidir ve bayt cinsinden ölçülen en kısa programı yazmaya çalışmalısınız. Elbette, bazı diller doğası gereği diğerlerinden daha kısa veya daha uzundur, bu nedenle hedefin mutlaka en kısa genel bayt sayısına sahip olmak değil, aynı veya benzer dillerde gönderimleri geçmek olduğunu unutmayın.

En iyi golfçü kazansın!

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

-gBayrak için +3 ve |tr . \*standart olmayan başlatma için +8 içerir (bu meta postayı gör )

Giriş, Hexagony'ye bir argüman olarak verilir. Altıgen tercüman -g Nseçeneği ile çağrıldığında, bir .s altıgen yazdırır . Onları *s ile değiştirmek için tr'i kullanırız .

Python 2,61 bayt

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

Her satırın sonuna sonunda bir boşluk basar.

Bayt Erik'e bir bayt tasarrufu sağladığı için teşekkür ederiz.

JavaScript (ES6), 77 81 84

@Yakınmacılar: @ETHproductions'un cevabını kaçırma, yani 76 bayt

Düzenle , değişiklik yapıldıktan sonra yeniden düzenlendi

Sadece şapka için ... hey! Şapka yok mu

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

Ölçek

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>

Altıgen , 91 87 86 bayt

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

Çevrimiçi deneyin!

Sonunda yaptı.

Başlangıçta (ne kadar pahalı döngüler olduğunu fark etmeden önce) Bunun, yan uzunluk 5'e sığabileceğini umuyorum, ancak şimdi yan kenar 6'ya sığdırmak için yeterince zor.

Bunu almak için aslında doğrusal kodu biraz değiştirmek zorundayım. Aslında, bu yazma beni aşağı tarafından golf doğrusal kodu bir yol gerçekleştirmek yapar 1 2 byte.

JavaScript (ES6), 77 76 bayt

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

Kendime diğer cevaplara bakmadan yeni bir ES6 kaydı ayarlayana kadar uyuyamayacağımı söyledim, işte burada ...

Test pasajı

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 bayt

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

Neredeyse doğru formülleri elde etmek için uğradım, sonra hepsini ezdim.

Nf numaralı numarayı arayın ve altıgeni stdout'a yazdırın.

Ungolfed ve açıkladı (80 bayt versiyonu):

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'da canlı görün

Notlar:

• printfNegatif dolguyu kaldırabilir, bu da sola hizalı bir karakterle sonuçlanır ve sağdaki dolguyla. Böylece w = printf("%*c*", y, ' ')mutlak değere dikkat etmesi için bir şeyler denedim , ve geri dönüş değerinden geri alabilirim. Maalesef, hem sıfır hem de bir dolgu genişliği, karakteri kendi başına basar, böylece üç merkez çizgisi aynıydı.
  Güncelleme: Jasen , karakter yerine boş bir dize yazdırarak bunu yapmanın bir yolunu buldu - 6 byte tıraş oldu!

• Geri alma karakteri Coliru tarafından yanlış işlenir - bu kodu yerel bir uçbirimde çalıştırmak, her satırdaki baştaki boşluğu kaldırır.

05AB1E , 14 13 bayt

Kod:

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

Açıklama:

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 kodlamasını kullanır . Çevrimiçi deneyin!

Jöle , 24 bayt

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

Çevrimiçi deneyin!

Jelly, bir merkezileşme atomuna sahip olmadığı gerçeğinden utanır, bu nedenle sırasıyla 05AB1E ve V ile dövülür!

Bunu golf oynamak için herhangi bir yol bulursanız, lütfen yorum yapın. Herhangi bir yardım takdir edilmektedir.

Açıklama :

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: Altıgende kaç yıldız olduğunu bulmak için şunu kullanın:

Ḷ×6S‘

Octave, 62 58 bayt

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

Önceki cevap:

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

buna denir

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

Octave Online'da (yapıştır) deneyin

Örneğin taban görüntüsü n=5olan

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 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

ile oluşturulabilir

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

dilation morphological operatorAşağıdaki komşu maskesi kullanarak görüntü üzerinde uygulanan 4 kez:

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

ile oluşturulabilir [k='01010'-48;~k;k]

genişlemenin sonucu:

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

daha sonra sırasıyla 0 ve 1'i '' ve '*' ile değiştirin

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

postgresql9.6, 290 bayt

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

biçimlendirilmiş sql burada:

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

çıktı:

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

V , 17 bayt

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

Çevrimiçi deneyin!

Her zamanki gibi, burada bir hexdump var, çünkü bu yazdırılamayan karakterler içeriyor:

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

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

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

Varsayalım ⎕IO←0, yani sıfır tabanlı indeksleme. Çıktı, her satırda bir satır ve bir satır boşluğu içerir.

Birçok golf için @ FrownyFrog ve @ ngn'a çok teşekkürler.

Çevrimiçi deneyin!

Nasıl çalışır

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

Bu benim ilk (kod golf) cevabım. Umarım her şeyi doğru biçimlendirmişimdir.

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

Mevcut 2 ES6 cevabının aksine, tekrar tekrar bir fonksiyon çağırmıyorum ve konsolu çıkış için kullanıyorum.

Haskell, 99 97 79 bayt

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

Açıklama: Bu program, bir n-Altıgen'in her bir satırının, satır numarasına bağlı bazı k için (nk) boşlukları ve ardından (n + k-1) yıldız işaretleri içerdiği gözlemine dayanmaktadır.

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 

Düzenleme: mapM_'ye geçti. Bunun ithalat kullanmadan kullanılabildiğini bilmiyordum

Python 2 , 100 97 89 88 87 81 79 bayt

-1 @ Flp.Tkc'den

Yine @Flp'den -6

-2 @ nedla2004 sayesinde. İkinci dilimden nasıl kurtulacağımı bulmaya çalışıyordum ama bunu düşünmedim :)

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

Çevrimiçi deneyin!

Üst yarı için bir dizi oluşturur, ardından ters diziyi eksi orta çizgiyi ekler ve ardından yazdırır. Tam olarak "olduğu gibi" 1yazdırır ve aralarında boşluk bırakmadan yazdırır (sanırım, buna izin verilen *görsel olarak *baş boşluklu ya da boşluksuzdur).

Toplu iş, 161 bayt

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

Not: 2. satırdaki arka alan. 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 bayt

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>

Tuval , 9 bayt

╷⁸＋* ×］／─

Burada dene!

Dahili dayak: D

Açıklama:

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

_{Neden devasa bir dolgu malzemesi olduğu hakkında hiçbir fikrim yok, ancak buna izin veriliyor. sabit? Umarım bir şeyleri kırmadım}

Perl 6 , 49 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Test komut dosyası:

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

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

Çıktı (ekstra boş alan):

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

Açıklama:

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 bayt

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

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Bu Kodos'un cevabına yakın ; ancak golf oynadıklarında bile str_paddaha kısa str_repeat.
Ve ++döngü başının içinde biraz daha fazla tasarruf sağlar.

Ruby, 54 bayt

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

lambda işlevi n'yi argüman olarak alır ve yeni satırlarla ayrılmış bir dize döndürür. ( $/varsayılan satır ayırıcıyı içeren bir değişkendir.)

test programında

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

puts f[gets.to_i]

Charly, 125 bayt

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 Sayfa: https://github.com/KCreate/charly-lang

SmileBASIC, 74 bayt

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

Önde gelen ve takip eden bir alan ekler.

Bu "altıgenler", karakterler aynı genişlikte ve yükseklikte olduğunda korkunç görünürler ...

raket / düzeni

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

test yapmak:

(f 1)
*

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

Python 2,111 bayt

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

Sıkıcı, basit bir uygulama (ve tam bir program). Her satırda izleyen bir boşluk bırakır.

testcases:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 bayt

Sonunda Noel tatili (mutlu Noeller!), Bu yüzden golf oynamak için biraz zamanım var.
Ve çocuk bir süre oldu - bu nedenle büyük bayt sayısı.
İşte gidiyor:

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 bayt

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 tarafından 8 byte çıkartıldı.
• 20 byte Kevin Cruijssen tarafından kaldırıldı.
• 2 byte Kevin Cruijssen tarafından kaldırıldı.

Çevrimiçi deneyin!

Altıgen (doğrusal), 128 127 126 bayt

Bunun Hexagony olmadığını , sadece Ezoterik IDE'de desteklenen bir (meta) dili olan Timwi olduğunu, bu nedenle ödül için uygun olmadığını unutmayın .

Ancak bu bir Hexagony çözümüne dönüştürülebilir (ve bu çözümden daha küçük olacağını düşünüyorum) daha sonra yapabilirim. Buraya daha çok çaba harcadım .

İlk ❢3 bayt alır (e2 9d a2 ) . Her yeni satır 1 bayt ( 0a) alır .

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

Hayır Çevrimiçi deneyin! Bu sadece Ezoterik IDE'de çalışır.

Açıklamalı kod:

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

Æ°çSi*Ãû ê

Deneyin (veya birden fazla test yapmak için TIO kullanın)

açıklama

               :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