Dzisiaj zrobimy sześciokąt ASCII. Musisz napisać program lub funkcję, która przyjmuje dodatnią liczbę całkowitą n i wyprowadza sześciokątną siatkę o rozmiarze n , złożoną z gwiazdek. Na przykład sześciokąt wielkości 2 wygląda następująco:

 * *
* * *
 * *

Podczas gdy sześciokąt wielkości 3 wygląda następująco:

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

Możesz użyć dowolnej z domyślnych metod wejścia i wyjścia , na przykład STDIO / STDOUT, argumentów funkcji i zwracanych wartości lub odczytu / zapisu pliku.

Możesz założyć, że dane wejściowe są zawsze prawidłowe, więc jeśli nie jest to dodatnia liczba całkowita, twój program może zrobić, co chcesz. Ci mają jednak trzeba obsłużyć szczególny przypadek rozmiar 1 sześciokąta, co dzieje się pojedyncza gwiazdka:

*

Wiodące i końcowe białe znaki są dozwolone, pod warunkiem, że wynik jest wizualnie taki sam.

Przykłady:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Jak zwykle jest to gra w golfa , więc obowiązują standardowe luki i powinieneś spróbować napisać możliwie najkrótszy program mierzony w bajtach. Oczywiście niektóre języki są z natury krótsze lub dłuższe niż inne, więc pamiętaj, że celem niekoniecznie jest uzyskanie najkrótszej ogólnej liczby bajtów, ale pokonanie zgłoszeń w tych samych lub podobnych językach.

Niech zwycięży najlepszy golfista!

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 bajtów

Obejmuje +3 za -gflagę i +8 za |tr . \*niestandardowe wywołanie (zobacz ten meta post )

Dane wejściowe są przekazywane jako argument do Hexagony. Po wywołaniu interpretera Sześciokąta z -g Nopcją drukuje sześciokąt .s. Następnie używamy tr, aby zastąpić je *s.

Python 2, 61 bajtów

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

Drukuje końcowe spacje na końcu każdej linii.

Dzięki Erikowi Outgolferowi za uratowanie bajtu.

JavaScript (ES6), 77 81 84

@Upvoters: nie przegap odpowiedzi autorstwa @ETHproductions, czyli 76 bajtów

Edytuj Zmieniono po zmianie specyfikacji, dozwolone końcowe miejsce

Tylko na czapkę ... hej! Nie ma kapelusza?

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

Test

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>

Sześciokąt , 91 87 86 bajtów

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

Wypróbuj online!

W końcu to zrobiłem.

Początkowo (zanim zdam sobie sprawę z tego, jak drogie są pętle) spodziewam się, że może zmieścić się w boku o długości 5, ale teraz trudno jest dopasować go do boku o długości 6.

Aby to uzyskać, muszę trochę zmodyfikować kod liniowy. W rzeczywistości napisanie tego sprawia, że ​​zdaję sobie sprawę z golfa kodu liniowego o 1 2 bajty.

JavaScript (ES6), 77 76 bajtów

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

Powiedziałem sobie, że nie będę spał, dopóki nie ustanowię nowego rekordu ES6, nie patrząc na inne odpowiedzi, więc oto ...

Testowy fragment kodu

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 bajty

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

Prawie poprawiłem, aby uzyskać prawidłowe formuły, a następnie zmiksowałem wszystko razem.

Zadzwoń fz numerem n , a wydrukuje sześciokąt na stdout.

Niegolfowane i wyjaśnione (wersja 80-bajtowa):

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
}

Zobacz na żywo na Coliru

Uwagi:

• printfradzi sobie z dopełnieniem ujemnym, co powoduje wyrównanie do lewej strony z dopełnieniem po prawej stronie. Próbowałem więc czegoś takiego, aby w = printf("%*c*", y, ' ')zajął się wartością bezwzględną i mogłem odzyskać ją z wartości zwracanej. Niestety zarówno szerokość wypełnienia zero, jak i jedna, same drukują znak, więc trzy linie środkowe były identyczne.
  Aktualizacja: Jasen znalazł sposób, aby to zrobić, drukując pusty ciąg zamiast znaku - wygolono 6 bajtów!

• Znak cofania jest nieprawidłowo obsługiwany przez Coliru - wykonanie tego kodu na lokalnym terminalu usuwa początkowe odstępy w każdym wierszu.

05AB1E , 14 13 bajtów

Kod:

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

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Galaretka , 24 bajty

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

Wypróbuj online!

Galaretka wstydzi się tego, że nie ma atomu centralizującego, więc została pobita przez 05AB1E i V. O odpowiednio 11 i 7 bajtów!

Jeśli znajdziesz jakiś sposób na grę w golfa, prosimy o komentarz. Każda pomoc jest mile widziana.

Objaśnienie :

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.

Premia: Aby sprawdzić, ile gwiazdek jest w sześciokącie, użyj tego:

Ḷ×6S‘

Oktawa, 62 58 bajtów

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

Poprzednia odpowiedź:

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

można to nazwać jako

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

Wypróbuj (wklej) w Octave Online

Na przykład obraz podstawowy n=5to

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

które można utworzyć za pomocą

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

Że dilation morphological operatorzastosowano 4 razy na obrazie stosując następujące maski sąsiada:

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

które można utworzyć za pomocą [k='01010'-48;~k;k]

wynik dylatacji:

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

następnie zamień 0 i 1 odpowiednio na „” i „*”

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

postgresql9.6, 290 bajtów

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

sformatowany sql jest tutaj:

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

wynik:

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

V , 17 bajtów

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

Wypróbuj online!

Jak zwykle, tutaj jest zrzut heksowy, ponieważ zawiera on niedrukowalne znaki:

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

APL (Dyalog Unicode) , 40 36 35 33 27 25 bajtów

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

Zakłada ⎕IO←0, tj. Indeksowanie od zera. Dane wyjściowe zawierają jedną spację wiodącą i jedną spację końcową w każdym wierszu.

Ogromne podziękowania dla @FrownyFrog i @ngn za dużo gry w golfa.

Wypróbuj online!

Jak to działa

(⍉⊖⍪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 bajtów

To moja pierwsza odpowiedź (code golf). Mam nadzieję, że sformatowałem wszystko poprawnie.

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

W przeciwieństwie do 2 bieżących odpowiedzi ES6, nie wywołuję rekurencyjnie funkcji i używam konsoli do wyjścia.

Haskell, 99 97 79 bajtów

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

Objaśnienie: Program ten opiera się na spostrzeżeniu, że każda linia n-Hexagon zawiera (nk) spacje, po których następują gwiazdki (n + k-1), dla niektórych k zależnych od numeru linii.

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 

Edycja: Przełączono na mapM_. Nie wiedziałem, że jest dostępny bez użycia importu

Python 2 , 100 97 89 88 87 81 79 bajtów

-1 z @ Flp.Tkc

-6 ponownie od @Flp

-2 dzięki dzięki @ nedla2004. Próbowałem znaleźć sposób na pozbycie się drugiego plasterka, ale nie pomyślałem o tym :)

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

Wypróbuj online!

Tworzy tablicę dla górnej połowy, następnie dodaje tablicę odwróconą minus środkową linię, a następnie drukuje. Drukuje dokładnie tak, jak jest, poza 1tym, że drukuje ze spacją wiodącą (wydaje mi się, że dozwolone jako a *jest wizualnie takie samo jak *z lub bez spacji wiodącej).

Partia, 161 bajtów

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

Uwaga: Końcowe spacje w linii 2. Nie golf:

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

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>

Płótno , 9 bajtów

╷⁸＋* ×］／─

Wypróbuj tutaj!

Pokonanie wbudowanego: D

Wyjaśnienie:

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

_{Nie mam pojęcia, dlaczego jest to duża wyściółka, ale jest to dozwolone i naprawię to wkrótce ™. naprawiony? Mam nadzieję, że nic nie zepsułem}

Perl 6 , 49 bajtów

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

Wypróbuj online!

Jak to działa

->\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 bajtów

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

Skrypt testowy:

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

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

Wyjście (dodatkowa spacja):

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

Wyjaśnienie:

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 bajtów

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

Uruchom jako potok z -nRlub spróbuj online .

Jest to bliskie odpowiedzi Kodos ; ale str_padjest krótszy niż str_repeatnawet podczas gry w golfa.
A ++w głowie pętla oszczędza trochę więcej.

Rubinowy, 54 bajty

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

Funkcja lambda przyjmuje n jako argument i zwraca ciąg oddzielony znakami nowej linii. ( $/jest zmienną zawierającą domyślny separator linii).

w programie testowym

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

puts f[gets.to_i]

Charly, 125 bajtów

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}

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

SmileBASIC, 74 bajty

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

Dodaje wiodące i końcowe miejsce.

Te „sześciokąty” wyglądają okropnie, gdy postacie mają tę samą szerokość i wysokość ...

rakieta / program

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

testowanie:

(f 1)
*

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

Python 2, 111 bajtów

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

Nudna, prosta implementacja (i pełny program). Zwraca końcowe białe znaki w każdej linii.

Przypadki testowe:

1:
*

2:
 * * 
* * * 
 * * 

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

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

JavaScript (ES6), 143 bajty

Nareszcie jest przerwa świąteczna (wesołych świąt!), Więc mam trochę czasu na grę w golfa.
A chłopcze minęło trochę czasu - stąd duża liczba bajtów.
Tutaj idzie:

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 bajtów

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 bajtów usuniętych przez Jonathana Frecha.
• 20 bajtów usuniętych przez Kevina Cruijssena.
• 2 bajty usunięte przez Kevina Cruijssena.

Wypróbuj online!

Sześciokąt (liniowy), 128 127 126 bajtów

Zauważ, że to nie jest heksagonia, tylko (meta-) język Timwi obsługiwany w Esoteric IDE, więc nie kwalifikuje się do nagrody.

Można to jednak przekonwertować na rozwiązanie sześciokątne (i myślę, że będzie mniejsze niż to rozwiązanie), mogę to zrobić później. Potrzebuję więcej wysiłku , żeby to tutaj zrobić .

Inicjał ❢zajmuje 3 bajty ( e2 9d a2). Każda nowa linia zajmuje 1 bajt ( 0a).

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

Nie Wypróbuj online! Działa to tylko w Esoteric IDE.

Kod z adnotacjami:

❢?        # 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 bajtów

Æ°çSi*Ãû ê

Wypróbuj (lub użyj TIO, aby uruchomić wiele testów)

Wyjaśnienie

               :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