Oggi faremo un esagono ASCII. È necessario scrivere un programma o una funzione che accetta un numero intero positivo n e genera una griglia esagonale di dimensione n , composta da asterischi. Ad esempio, un esagono di dimensioni 2 è simile al seguente:

 * *
* * *
 * *

Mentre un esagono di dimensione 3 è simile al seguente:

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

È possibile utilizzare uno qualsiasi dei metodi di input e output predefiniti , ad esempio STDIO / STDOUT, argomenti di funzioni e valori di ritorno o leggere / scrivere un file.

Puoi supporre che l'input sia sempre valido, quindi se non è un numero intero positivo, il tuo programma potrebbe fare quello che vuoi. Si fa tuttavia necessario gestire il caso particolare di una dimensione di 1 esagono, che risulta essere un singolo asterisco:

*

Gli spazi bianchi iniziali e finali sono consentiti purché l'output sia visivamente lo stesso.

Esempi:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Come al solito, si tratta di code-golf , quindi si applicano scappatoie standard e si dovrebbe provare a scrivere il programma più breve possibile misurato in byte. Certo, alcune lingue sono intrinsecamente più brevi o più lunghe di altre, quindi ricorda che l'obiettivo non è necessariamente quello di avere il conteggio complessivo dei byte più breve, ma di battere gli invii nelle stesse lingue o in lingue simili.

Che vinca il migliore golfista!

Esagonia + Bash Coreutils, 0 + 3 + 8 = 11 byte

Include +3 per -gflag e +8 per |tr . \*invocazione non standard (vedi questo meta post )

L'input è dato come argomento a Hexagony. Quando viene chiamato l'interprete Hexagony con l' -g Nopzione, stampa un esagono di .s. Quindi usiamo tr per sostituire quelli con *s.

Python 2, 61 byte

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

Stampa uno spazio finale alla fine di ogni riga.

Grazie a Erik Outgolfer per aver salvato un byte.

JavaScript (ES6), 77 81 84

@Upvoters: non perdere la risposta di @ETHproductions, ovvero 76 byte

Modifica Revisionato dopo la modifica delle specifiche, spazio finale consentito

Solo per il cappello ... ehi! Nessun cappello?

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>

Esagonia , 91 87 86 byte

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

Provalo online!

Finalmente lo ha fatto.

Inizialmente (prima di rendermi conto di quanto siano costosi gli anelli) mi aspetto che questo possa adattarsi alla lunghezza laterale 5, ma ora è abbastanza difficile adattarlo alla lunghezza laterale 6.

Per ottenere questo devo effettivamente modificare un po 'il codice lineare. In effetti, scrivere questo mi fa capire un modo per golfare il codice lineare di 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

Mi sono detto che non avrei dormito fino a quando non avessi stabilito un nuovo record ES6 senza guardare le altre risposte, quindi eccolo ...

Snippet di prova

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(" *"););}

Ho praticamente ottimizzato per ottenere le formule corrette, quindi ho mescolato tutto insieme.

Chiama fcon il numero n e stamperà l'esagono su stdout.

Non salvato e spiegato (versione a 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
}

Guardalo dal vivo su Coliru

Appunti:

• printfpuò gestire il riempimento negativo, che si traduce in un carattere allineato a sinistra con il riempimento a destra. Così ho provato a fare qualcosa in w = printf("%*c*", y, ' ')modo che si prendesse cura del valore assoluto e potevo recuperarlo dal suo valore di ritorno. Sfortunatamente, entrambe le larghezze di zero e una di riempimento stampano il carattere da solo, quindi le tre linee centrali erano identiche.
  Aggiornamento: Jasen ha trovato il modo di fare esattamente questo stampando una stringa vuota invece di un carattere - 6 byte rasati!

• Il carattere backspace viene gestito in modo errato da Coliru: l'esecuzione di questo codice su un terminale locale rimuove lo spazio iniziale su ogni riga.

05AB1E , 14 13 byte

Codice:

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

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online!

Gelatina , 24 byte

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

Provalo online!

Jelly si vergogna del fatto che non abbia un atomo di centralizzazione, quindi è battuto da 05AB1E e V. Da 11 e 7 byte rispettivamente!

Se trovi un modo per giocare a golf, commenta. Qualsiasi aiuto è apprezzato.

Spiegazione :

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: per trovare quante stelle ci sono in un esagono, usa questo:

Ḷ×6S‘

Ottava, 62 58 byte

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

Risposta precedente:

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

che può essere chiamato come

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

Prova (incollalo) su Octave Online

Ad esempio l'immagine di base per 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

che può essere creato con

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

Le sono state dilation morphological operatorapplicate 4 volte sull'immagine usando la seguente maschera vicina:

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

che può essere creato con [k='01010'-48;~k;k]

risultato di dilatazione:

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

quindi sostituire 0 e 1 con '' e '*' rispettivamente

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

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 formattato è qui:

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

produzione:

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

V , 17 byte

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

Provalo online!

Come al solito, ecco un dump esadecimale, poiché contiene caratteri non stampabili:

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∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

Presuppone ⎕IO←0, cioè indicizzazione a base zero. L'output contiene uno spazio iniziale e uno finale su ogni riga.

Mille grazie a @FrownyFrog e @ngn per il golf.

Provalo online!

Come funziona

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

Questa è la mia prima risposta (codice golf). Spero di aver formattato tutto correttamente.

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

A differenza delle 2 risposte ES6 attuali, non sto chiamando ricorsivamente una funzione e sto usando la console per l'output.

Haskell, 99 97 79 byte

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

Spiegazione: Questo programma si basa sull'osservazione che ogni riga di un n-esagono contiene (nk) spazi seguiti da (n + k-1) asterischi, per alcuni k dipendenti dal numero di linea.

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 

Modifica: passato a mapM_. Non sapevo che fosse disponibile senza usare l'importazione

Python 2 , 100 97 89 88 87 81 79 byte

-1 da @ Flp.Tkc

-6 di nuovo da @Flp

-2 grazie a @ nedla2004. Stavo cercando di trovare come sbarazzarmi della seconda fetta ma non ci ho pensato :)

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

Provalo online!

Crea un array per la metà superiore, quindi aggiunge l'array invertito meno la linea centrale, quindi stampa. Stampa esattamente "così com'è" a parte il 1quale stampa con uno spazio iniziale (immagino che ciò che è consentito *sia visivamente lo stesso di uno *con o senza uno spazio iniziale).

Lotto, 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%%

Nota: spazio finale sulla riga 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 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>

Tela , 9 byte

╷⁸＋* ×］／─

Provalo qui!

Battere il built-in: D

Spiegazione:

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

_{Non ho idea del perché ci sia un'enorme imbottitura, ma è permesso e lo risolverò presto ™. fisso? Spero di non aver rotto cose}

Perl 6 , 49 byte

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

Provalo online!

Come funziona

->\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-$_)}

Script di prova:

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

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

Output (spazio iniziale aggiuntivo):

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

Spiegazione:

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,"* ");

Esegui come pipe -nRo provalo online .

Questo è vicino alla risposta di Kodos ; ma str_padè più corto str_repeatanche se golfato.
E la ++testa nel loop ne salva un po 'di più.

Rubino, 54 byte

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

La funzione lambda prende n come argomento e restituisce una stringa separata da newline. ( $/è una variabile che contiene il separatore di riga predefinito.)

nel programma di test

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}

Pagina 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

Aggiunge uno spazio iniziale e finale.

Questi "esagoni" sembrano orribili quando i personaggi hanno la stessa larghezza e altezza ...

racchetta / schema

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

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

Un'implementazione noiosa e semplice (e un programma completo). Emette uno spazio bianco finale su ogni riga.

Casi test:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 byte

È finalmente la pausa di Natale (buon Natale!), Quindi ho un po 'di tempo per giocare a golf.
E ragazzo è passato un po 'di tempo - da qui il grande conteggio dei byte.
Ecco qui:

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

Provalo online!

Esagonia (lineare), 128 127 126 byte

Nota che questo non è Esagonia, solo un Timwi (meta-) lingua supportato in IDE esoterico, quindi questo non è idoneo per la generosità.

Tuttavia, questo può essere convertito in una soluzione Hexagony (e penso che sarà più piccola di questa soluzione), potrei farlo in seguito. Ci vuole più impegno per farlo qui .

L'iniziale ❢richiede 3 byte ( e2 9d a2). Ogni newline richiede 1 byte ( 0a).

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

No Provalo online !. Questo solo funziona in Esoteric IDE.

Codice annotato:

❢?        # 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*Ãû ê

Provalo (o usa TIO per eseguire più test)

Spiegazione

               :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