Você poderia me fazer um hexágono, por favor?


53

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


15
Por que temos uma etiqueta de grade hexagonal?
Pavel

13
Além disso, alguém precisa escrever uma solução hexagônica.
Pavel

Se alguém quiser ir atrás da recompensa, provavelmente poderá reutilizar o loop de saída da minha resposta Hexagony aqui .
Martin Ender

6
"Você poderia me fazer um hexágono, por favor?" - claro, aqui está: i.imgur.com/1emYIia.png
aditsu

@ Pavel porque muitas operações em uma grade hexagonal são distintas da grade quadrada mais padrão e portáteis entre soluções para diferentes problemas. Operações como manipulação de coordenadas, rotação, layout de saída etc.
Sparr

Respostas:


37

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.


2
Uau, isso é genial. E você está vencendo todas as línguas do golfe!
DJMcMayhem

6
Eu realmente não chamaria isso usando a linguagem Hexagony, mais como usar o bash (ou algum outro shell) com o interpretador Hexagony como um dos comandos. Isso seria hexagony -g $1|tr . \*, por exemplo , supondo que o intérprete de hexagonia seja nomeado dessa maneira.
Paŭlo Ebermann

3
Isso beneficiaria de um comando real, executável ...
jpmc26

11
@ jpmc26 Para um comprimento de 5 hex você iria correrruby ./interpreter.rb -g 5|tr . \*
Riley

3
@OlivierDulac O "programa" tem zero bytes. Todo o trabalho está sendo feito pelas "bandeiras".
Riley #

20

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.


Começando com isso, você obtém um código Python 3 não PEP8, mas válido, com 69 bytes, em int(input())vez de input()e com a print(' '*j+'* '*(2*n+~j))substituição usual print' '*j+'* '*(2*n+~j)- código legal btw ;-)
Diletant

Esse é um código muito legal!
Matias Bjarland

13

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>


11

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.


10

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


10

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.


w=printf("\n%*s",abs(y),"");++w<s*printf(" *");
Jasen

@ Jason Eu não posso acreditar que perdi isso ... Obrigado!
Quentin

9

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!


11
Não entendo o que a parte "centralizar" faz. Ao removê-lo, recebo uma matriz de seqüências de caracteres sem o número apropriado de espaços à esquerda.
DJMcMayhem

11
@DJMcMayhem Em uma matriz, você pode vê-la como se fosse uma string unida por novas linhas com o texto alinhado ao centro. Isto é o que faz na entrada.
Adnan

8

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‘

2
Ufa, a explicação foi esmagadora.
Erik the Outgolfer,

O que um "átomo de centralização" faria?
DJMcMayhem

@DJMcMayhem Veja a resposta 05AB1E para um exemplo.
Erik the Outgolfer

7

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

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

6

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

lpadpoderá economizar alguns bytes. Eu também chamaria o idioma pl / pgsql, mas isso levanta questões sobre se você precisa contar do language plpgsql $$o fechamento e o fechamento $$;. Isso seria melhor abordado na meta, se não surgiram antes.
jpmc26

Além disso, por que você precisa de vários DECLAREs? Um único não funcionaria?
jpmc26

6

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                                       .

6

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

5

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.


Você poderia usar alertse especificar o navegador js?
FlipTack

@ FlipTack, na verdade não, pois eu gradualmente construo a string (linha por linha). Se eu alerteditasse, alertaria linha por linha, e não a coisa toda.
Lucas

5

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


5

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


11
Isso fornece uma solução incorreta para 1 - "*". Eu acho que deveria ser asterisco sem espaço na frente?
Андрей Ломакин

@ АндрейЛомакин - No OP: "Espaços em branco à esquerda e à direita são permitidos desde que a saída seja visualmente a mesma." Uma única estrela é visualmente o mesmo que uma única estrela com um espaço em frente do mesmo, ou pelo menos essa foi a minha interpretação ;-)
ElPedro

Mas você está realmente correto, pois contradiz o que acabei de dizer na minha resposta. Atualizei a resposta para esclarecer. Melhor agora? BTW, bom trabalho em encontrar uma resposta antiga e detectar um erro em potencial. Respeito.
ElPedro 01/08/19

11
Eu mesmo estava tentando esse desafio, e não consigo pensar em nada melhor, estava estudando o seu em busca de inspiração.
Андрей Ломакин

Espero que meu humilde esforço tenha ajudado você. Claro que nos divertiremos jogando golfe juntos no futuro. Aproveite o PPCG. Eu com certeza fazer ☺
ElPedro

4

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

4

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>


4

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


3

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

3

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

11
Bom uso de gu.
AdmBorkBork

3

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.


2

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]

Você pode salvar 1 byte usando (1-n ... n) com 3 pontos
GB

Parece consenso incluir o código de saída (ou seja puts) na contagem de caracteres. Mas, relendo a definição, ela diz apenas que sua função deve "gerar" o resultado que pode ser lido como "retornar" o resultado. Solução legal.
Matias Bjarland



2

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


2

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

3
Bem vindo ao site! Esta é uma competição de golfe com código, portanto você deve incluir sua contagem de bytes. Além disso, você pode remover muitos espaços em branco presentes nesta resposta para reduzi-lo.
Assistente de trigo

Obrigado pela sua contribuição, Assistente de gato. Eu sou novo em codificar golfe, e suponho que o esquema não seja a melhor linguagem para ele, mas tentarei encurtá-lo, eliminar espaços em branco e adicionar uma contagem de bytes na minha próxima entrada.
Kevin

2

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

2

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


2
Algumas melhorias: for(j=c.length-2;j>-1;j--)c.push(c[j])podem ser escritas como for(j=a-1;j;c.push(c[--j]))e for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}podem ser for(i=0;i<a;c.push(" ".repeat(a-i-1)+"* ".repeat(a-1+i++));. A declaração de retorno pode ser reduzida para return a-1?c.join\ n :"*"No total, essas alterações economizam 18B (11 + 7 + 1).
Luke

2

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!



11
94 bytes. NOTA: O Java 11 possui String#repeat(int), mas o TIO ainda é o JDK 10, portanto, o repeat(String,int)método emulado (com a mesma contagem de bytes). O código real em Java 11 seria:s->{for(int j=~--s,t;++j<=s;System.out.println(" ".repeat(t)+"* ".repeat(s-~s-t)))t=j<0?-j:j;}
Kevin Cruijssen

11
@Eugene Sure. :) Nesse caso, algumas coisas para jogar na versão atual do Java (8+) por enquanto: 129 bytes .
Kevin Cruijssen

11
@KevinCruijssen Isso é um golfe pesado aqui, atualizei-o, obrigado.
187 Eugene

11
Eu de novo. Encontrou mais uma coisa no golfe por -2 bytes. 127 bytes Isso também pode ser usado para obter 1 byte de golfe na solução Java 11 acima .
Kevin Cruijssen

2

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
@

2

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.