Hoy, vamos a hacer un hexágono ASCII. Debe escribir un programa o función que tome un entero positivo n y genere una cuadrícula hexagonal de tamaño n , compuesta de asteriscos. Por ejemplo, un hexágono de tamaño 2 se ve así:

 * *
* * *
 * *

Mientras que un hexágono de tamaño 3 se ve así:

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

Puede utilizar cualquiera de los métodos de entrada y salida predeterminados , por ejemplo, STDIO / STDOUT, argumentos de función y valores de retorno o leer / escribir un archivo.

Puede suponer que la entrada siempre es válida, por lo que si no es un número entero positivo, su programa puede hacer lo que quiera. Usted no obstante tiene que manejar el caso especial de un hexágono tamaño 1, que pasa a ser un solo asterisco:

*

Los espacios en blanco iniciales y finales están permitidos siempre que la salida sea visualmente la misma.

Ejemplos:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Como de costumbre, este es el código de golf , por lo que se aplican las lagunas estándar , y debe intentar escribir el programa más corto posible medido en bytes. Por supuesto, algunos idiomas son inherentemente más cortos o más largos que otros, así que recuerde que el objetivo no es necesariamente tener el recuento de bytes general más corto, sino superar las presentaciones en los mismos idiomas o en idiomas similares.

¡Que gane el mejor golfista!

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

Incluye +3 para -gbandera y +8 para |tr . \*invocación no estándar (vea esta meta publicación )

La entrada se da como argumento para Hexagony. Cuando se llama al intérprete de Hexagony con la -g Nopción, imprime un hexágono de .s. Luego usamos tr para reemplazar aquellos con *s.

Python 2, 61 bytes

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

Imprime un espacio final al final de cada línea.

Gracias a Erik the Outgolfer por guardar un byte.

JavaScript (ES6), 77 81 84

@Upvoters: no te pierdas la respuesta de @ETHproductions, es decir 76 bytes

Editar Revisado después de un cambio en las especificaciones, se permite el espacio final

Solo por el sombrero ... hey! ¿Sin sombrero?

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

Prueba

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>

Hexagonía , 91 87 86 bytes

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

Pruébalo en línea!

Finalmente lo hice.

Inicialmente (antes de darme cuenta de lo caros que son los bucles), espero que esto pueda caber en la longitud lateral 5, pero ahora es bastante difícil ajustarlo en la longitud lateral 6.

Para obtener esto, en realidad tengo que modificar un poco el código lineal. De hecho, escribir esto me hace darme cuenta de una manera de reducir el código lineal en 1 2 byte.

JavaScript (ES6), 77 76 bytes

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

Me dije que no dormiría hasta haber establecido un nuevo récord ES6 sin mirar las otras respuestas, así que aquí está ...

Fragmento de prueba

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 bytes

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

Prácticamente modifiqué para obtener las fórmulas correctas, luego las mezclé todas juntas.

Llame fcon el número n , e imprimirá el hexágono en stdout.

Ungolfed y explicado (versión de 80 bytes):

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
}

Véalo en vivo en Coliru

Notas:

• printfpuede manejar el relleno negativo, lo que da como resultado un carácter alineado a la izquierda con el relleno a la derecha. Por lo tanto, probé algo para w = printf("%*c*", y, ' ')que se hiciera cargo del valor absoluto y pudiera recuperarlo de su valor de retorno. Desafortunadamente, los anchos de relleno cero y uno imprimen el carácter por sí mismo, por lo que las tres líneas centrales eran idénticas.
  Actualización: Jasen ha encontrado una manera de hacer exactamente esto imprimiendo una cadena vacía en lugar de un carácter: ¡6 bytes eliminados!

• Coliru maneja incorrectamente el carácter de retroceso: la ejecución de este código en un terminal local elimina el espacio inicial de cada línea.

05AB1E , 14 13 bytes

Código:

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

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Jalea , 24 bytes

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

Pruébalo en línea!

Jelly se avergüenza del hecho de que no tiene un átomo de centralización, por lo que es superado por 05AB1E y V. ¡Por 11 y 7 bytes respectivamente!

Si encuentra alguna forma de jugar al golf, por favor comente. Cualquier ayuda es apreciada.

Explicacion :

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.

Bonificación: para encontrar cuántas estrellas hay en un hexágono, usa esto:

Ḷ×6S‘

Octava, 62 58 bytes

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

Respuesta anterior:

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

que se puede llamar como

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

Pruébalo (pégalo) en Octave Online

Por ejemplo, la imagen base para n=5es

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

que se puede crear con

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

Se dilation morphological operatoraplica 4 veces en la imagen usando la siguiente máscara vecina:

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

que se puede crear con [k='01010'-48;~k;k]

resultado de la dilatación:

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

luego reemplace 0 y 1 con '' y '*' respectivamente

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

postgresql9.6, 290 bytes

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 formateado está aquí:

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

salida:

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

V , 17 bytes

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

Pruébalo en línea!

Como de costumbre, aquí hay un hexdump, ya que contiene caracteres no imprimibles:

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

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

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

Asume ⎕IO←0, es decir, indexación basada en cero. La salida contiene un espacio inicial y uno posterior en cada línea.

Muchas gracias a @FrownyFrog y @ngn por mucho golf.

Pruébalo en línea!

Cómo funciona

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

Esta es mi primera respuesta (código golf). Espero haber formateado todo correctamente.

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

A diferencia de las 2 respuestas actuales de ES6, no estoy llamando recursivamente a una función y estoy usando la consola para la salida.

Haskell, 99 97 79 bytes

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

Explicación: Este programa se basa en la observación de que cada línea de un n-Hexágono contiene espacios (nk) seguidos de asteriscos (n + k-1), para algunos k dependiendo del número de línea.

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 

Editar: se cambió a mapM_. No sabía que estaba disponible sin usar importar

Python 2 , 100 97 89 88 87 81 79 bytes

-1 de @ Flp.Tkc

-6 de nuevo desde @Flp

-2 con agradecimiento a @ nedla2004. Estaba tratando de encontrar cómo deshacerme de la segunda porción, pero no pensé en esa :)

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

Pruébalo en línea!

Crea una matriz para la mitad superior, luego agrega la matriz invertida menos la línea media y luego imprime. Imprime exactamente "tal cual", aparte de lo 1que imprime con un espacio inicial (supongo que eso está permitido ya *que visualmente es lo mismo que *con o sin espacio inicial).

Lote, 161 bytes

@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: Espacio final en la línea 2. Sin 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 bytes

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>

Lienzo , 9 bytes.

╷⁸＋* ×］／─

Pruébalo aquí!

Vencer a la incorporada: D

Explicación:

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

_{No tengo idea de por qué existe el gran relleno, pero está permitido y lo arreglaré pronto ™. ¿fijo? Espero no haber roto cosas}

Perl 6 , 49 bytes

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

Pruébalo en línea!

Cómo funciona

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

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

Script de prueba:

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

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

Salida (espacio inicial adicional):

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

Explicación:

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 bytes

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

Ejecutar como tubería -nRo probarlo en línea .

Esto está cerca de la respuesta de Kodos ; pero str_pades más corto que str_repeatincluso cuando se juega al golf.
Y la ++cabeza en el bucle ahorra un poco más.

Ruby, 54 bytes

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

La función lambda toma n como argumento y devuelve una cadena separada por nuevas líneas. ( $/es una variable que contiene el separador de línea predeterminado).

en programa de prueba

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

puts f[gets.to_i]

Charly, 125 bytes

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}

Página de Charly GitHub: https://github.com/KCreate/charly-lang

SmileBASIC, 74 bytes

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

Agrega un espacio inicial y final.

Estos "hexágonos" se ven horribles cuando los personajes tienen el mismo ancho y alto ...

raqueta / esquema

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

pruebas:

(f 1)
*

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

Python 2, 111 bytes

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

Una implementación aburrida y directa (y un programa completo). Emite un espacio en blanco al final de cada línea.

Casos de prueba:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 bytes

Finalmente son las vacaciones de Navidad (¡feliz Navidad!), Así que tengo tiempo para jugar al golf.
Y vaya, ha pasado un tiempo, de ahí el gran número de bytes.
Aquí va:

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 bytes

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 bytes eliminados por Jonathan Frech.
• 20 bytes eliminados por Kevin Cruijssen.
• 2 bytes eliminados por Kevin Cruijssen.

Pruébalo en línea!

Hexagonía (lineal), 128 127 126 bytes

Tenga en cuenta que esto no es Hexagony, solo un (meta) lenguaje admitido por Timwi en IDE esotérico, por lo que no es elegible para la recompensa.

Sin embargo, esto se puede convertir en una solución de Hexagony (y creo que será más pequeña que esta solución). Puedo hacerlo más tarde. Se necesita más esfuerzo lo hice aquí .

La inicial ❢toma 3 bytes ( e2 9d a2). Cada línea nueva toma 1 byte ( 0a).

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

No ¡Pruébelo en línea! Esto solo funciona en IDE esotérico.

Código anotado:

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

Æ°çSi*Ãû ê

Pruébelo (o use TIO para ejecutar múltiples pruebas)

Explicación

               :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