Hoje, vamos fazer um hexágono ASCII. Você deve escrever um programa ou função que use um número inteiro positivo n e produza uma grade hexagonal de tamanho n , composta de asteriscos. Por exemplo, um hexágono de tamanho 2 se parece com isso:

 * *
* * *
 * *

Enquanto um hexágono de tamanho 3 se parece com isso:

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

Você pode usar qualquer um dos métodos de entrada e saída padrão , por exemplo, STDIO / STDOUT, argumentos de função e valores de retorno ou leitura / gravação de um arquivo.

Você pode assumir que a entrada é sempre válida; portanto, se não for um número inteiro positivo, seu programa poderá fazer o que quiser. Você não no entanto, ter de lidar com o caso especial de um hexágono tamanho 1, que acontece de ser um único asterisco:

*

Os espaços em branco à esquerda e à direita são permitidos desde que a saída seja visualmente a mesma.

Exemplos:

1:
*

2:
 * *
* * *
 * *

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

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

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

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

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

Como de costume, esse é um código de golfe , então as brechas padrão se aplicam e você deve tentar escrever o programa mais curto possível medido em bytes. É claro que alguns idiomas são inerentemente mais curtos ou mais longos que outros, portanto, lembre-se de que o objetivo não é necessariamente ter a menor contagem geral de bytes, mas vencer os envios nos mesmos idiomas ou em idiomas semelhantes.

Que ganhe o melhor jogador de golfe!

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

Inclui +3 para -gsinalizador e +8 para |tr . \*invocação fora do padrão (consulte esta meta post )

A entrada é fornecida como argumento para o Hexagony. Quando o intérprete Hexagony é chamado com a -g Nopção, ele imprime um hexágono de .s. Em seguida, usamos tr para substituir aqueles por *s.

Python 2, 61 bytes

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

Imprime um espaço à direita no final de cada linha.

Agradecimentos a Erik, o Outgolfer, por salvar um byte.

JavaScript (ES6), 77 81 84

@Upvoters: não perca a resposta de @ETHproductions, ou seja, 76 bytes

Edição revisada após alteração nas especificações, espaço à direita permitido

Só pelo chapéu ... ei! Sem chapéu?

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

Teste

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>

Hexagonia , 91 87 86 bytes

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

Experimente online!

Finalmente consegui.

Inicialmente (antes de perceber o quanto os loops são caros), espero que isso possa caber no comprimento lateral 5, mas agora é difícil o suficiente para ajustá-lo no comprimento lateral 6.

Para conseguir isso, preciso modificar um pouco o código linear. De fato, escrever isso me faz perceber uma maneira de reduzir o código linear em 1 2 bytes.

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

Eu disse a mim mesma que não iria dormir até ter estabelecido um novo recorde de ES6 sem olhar para as outras respostas, então aqui está ...

Snippet de teste

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

Eu mudei para obter as fórmulas corretas e depois misturei tudo.

Ligue fcom o número n e imprimirá o hexágono em stdout.

Ungolfed e explicado (versão 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
}

Veja ao vivo em Coliru

Notas:

• printfpode lidar com preenchimento negativo, o que resulta em um caractere alinhado à esquerda com o preenchimento à direita. Assim, tentei algo para o efeito, w = printf("%*c*", y, ' ')para que ele cuidasse do valor absoluto e pudesse recuperá-lo de seu valor de retorno. Infelizmente, as larguras de preenchimento zero e uma imprimem o caractere por si só, portanto as três linhas centrais eram idênticas.
  Atualização: Jasen encontrou uma maneira de fazer exatamente isso, imprimindo uma string vazia em vez de um caractere - 6 bytes raspados!

• O caractere de backspace é tratado incorretamente pelo Coliru - a execução desse código em um terminal local remove o espaço inicial em cada linha.

05AB1E , 14 13 bytes

Código:

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

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

Gelatina , 24 bytes

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

Experimente online!

A geléia tem vergonha do fato de não ter um átomo de centralização, por isso é batida por 05AB1E e V. Por 11 e 7 bytes, respectivamente!

Se você encontrar alguma maneira de jogar isso, comente. Qualquer ajuda é apreciada.

Explicação :

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.

Bônus: Para descobrir quantas estrelas existem em um hexágono, use o seguinte:

Ḷ×6S‘

Oitava, 62 58 bytes

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

Resposta anterior:

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

que pode ser chamado como

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

Experimente (cole) no Octave Online

Por exemplo, a imagem base para 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

que pode ser criado com

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

O dilation morphological operatoraplicado 4 vezes na imagem usando a seguinte máscara de vizinho:

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

que pode ser criado com [k='01010'-48;~k;k]

resultado da dilatação:

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

substitua 0 e 1 por '' e '*' 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 formatado está aqui:

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

resultado:

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

V , 17 bytes

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

Experimente online!

Como de costume, aqui está um hexdump, pois contém caracteres não imprimíveis:

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

Assume ⎕IO←0 , ou seja, indexação baseada em zero. A saída contém um espaço à esquerda e um à direita em cada linha.

Muito obrigado a @FrownyFrog e @ngn por muito golfe.

Experimente online!

Como 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 é minha primeira resposta (código golf). Espero ter formatado tudo corretamente.

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

Diferentemente das 2 respostas atuais do ES6, não estou chamando recursivamente uma função e estou usando o console para saída.

Haskell, 99 97 79 bytes

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

Explicação: Este programa é baseado na observação de que cada linha de um n-Hexágono contém espaços (nk) seguidos por asteriscos (n + k-1), para alguns k dependentes do número da linha.

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: Alterado para mapM_. Eu não sabia que estava disponível sem usar a importação

Python 2 , 100 97 89 88 87 81 79 bytes

-1 de @ Flp.Tkc

-6 novamente a partir @Flp

-2 com agradecimentos a @ nedla2004. Eu estava tentando descobrir como me livrar da segunda fatia, mas não pensei nessa :)

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

Experimente online!

Cria uma matriz para a metade superior e depois adiciona a matriz reversa menos a linha do meio e depois imprime. Imprime exatamente "como está", além do 1que imprime com um espaço à esquerda (acho que isso é permitido como a *é visualmente o mesmo que um *com ou sem um espaço à esquerda).

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: Trailing space na linha 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 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>

Tela , 9 bytes

╷⁸＋* ×］／─

Experimente aqui!

Vencendo o built-in: D

Explicação:

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

_{Não faço ideia do porquê do estofamento enorme, mas é permitido e estou corrigindo isso em breve ™. fixo? Espero não ter quebrado coisas}

Perl 6 , 49 bytes

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

Experimente online!

Como 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 teste:

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

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

Saída (espaço extra à esquerda):

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

Explicação:

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

Execute como pipe -nRou experimente online .

Isso é próximo da resposta de Kodos ; mas str_padé mais curto do que str_repeatquando jogado.
E a ++cabeça do laço economiza um pouco mais.

Ruby, 54 bytes

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

A função lambda recebe n como argumento e retorna uma sequência separada por novas linhas. ( $/é uma variável que contém o separador de linhas padrão.)

no programa de teste

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

Adiciona um espaço inicial e final.

Esses "hexágonos" parecem horríveis quando os caracteres têm a mesma largura e altura ...

raquete / 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)))

Testando:

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

Uma implementação chata e direta (e um programa completo). Gera um espaço em branco à direita em cada linha.

Casos de teste:

1:
*

2:
 * * 
* * * 
 * * 

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

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

Javascript (ES6), 143 bytes

Finalmente é feriado de Natal (feliz Natal!), Então tenho tempo para jogar golfe.
E garoto, já faz um tempo - daí a grande contagem de bytes.
Aqui vai:

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

Experimente online!

Hexagonia (linear), 128 127 126 bytes

Observe que isso não é Hexagony, apenas um (meta) idioma Timwi suportado no IDE esotérico, portanto, não é elegível para a recompensa.

No entanto, isso pode ser convertido em uma solução Hexagony (e acho que será menor que essa solução). Posso fazer isso mais tarde. É preciso mais esforço que eu fiz aqui .

A inicial ❢ocupa 3 bytes ( e2 9d a2). Cada nova linha ocupa 1 byte ( 0a).

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

Não Experimente online !. Isso funciona apenas no 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*Ãû ê

Experimente (ou use o TIO para executar vários testes)

Explicação

               :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