Desenhe um hexágono ASCII de comprimento lateral n

Question

Dado um número inteiro positivo \$n\$produzir um hexágono ASCII com comprimento do lado diagonal \$n\$, conforme ilustrado (observe que há \$2n\$ _ caracteres na borda superior)

Exemplos:

\$n = 1\$

 __
/  \
\__/

\$n = 2\$

  ____
 /    \
/      \
\      /
 \____/

\$n = 5\$

     __________
    /          \
   /            \
  /              \
 /                \
/                  \
\                  /
 \                /
  \              /
   \            /
    \__________/

etc.

O código mais curto em bytes vence. Métodos usuais de entrada / saída se aplicam.

Answer 1

Canvas , ¹⁵ 9 bytes

 _；１＊⁸／∔╬

Experimente aqui!

-6 bytes após corrigir o programa.

Desenha um quarto do hexágono e o quad palindromiza.

Answer 2

Python 2 , 92 bytes

k=n=input()
while 1:a=k^k>>n;print" "*a+"\/_"[k/n-2]+"_ "[-n<k<n]*2*(2*n+~a)+"\_/"[k/n];k-=1

Experimente online!

Answer 3

Carvão , 14 bytes

←×_θ↖θ→↗θ×_θ‖Ｍ

Experimente online!

Correção de 1 byte somente para ASCII.

Desenha metade do hexágono e o espelha.

Answer 4

C (gcc) , 119 109 bytes

a,i,j;f(n){for(i=a+=a=j=n*2;~j;)putchar(!i--?i=a,j--,13:i%(n*3)<n|j%(n*2)?(i-~j-n)%a?(i-j+n)%a?32:92:47:95);}

Experimente online!

• economizou 2 graças a @ceilingcat

A tabela abaixo não é atualizada, portanto os valores podem ser diferentes, mas o conceito é:

• temos 2 pares de linhas paralelas

        . .
_______.______.________   
  | / \ | .
. | / \ | .
 . | / \ |.
  | / \ |
  | \ / |.
 . | \ / | .
. | \ / |
__ | ___ \ ________ / ___ | ___   
  | . .

iteramos x, y do tamanho para 0 e somamos para verificar se a / deve ser impresso, subtraímos para verificar \, usamos módulo para verificar os dois paralelos.

    i 65432109876543210. j
 i + jn ________ 8 
13 + 7-4 => / \ 7 
14 + 6-4 / \ 6 
15 + 5-4 / \ 5 
      / \ 4 
      \ 1 + 3-4 => / 3
       \ 2 + 2-4 / 2
        \ 3 + 1-4 / 1
         \ ________ / 0

Answer 5

Perl 5 ( -p), 102 bytes

s/_+/__$&/g,s/^|$/ /gm,s/^ *\S /$& /gm,s-( +)\\ -$&/ $1 \\ \\ $1 /
- for($\=' __ / \ \__/')x--$_}{

Experimente online!

-pe }{no final é um truque para imprimir apenas o separador de registro de saída $\no final. Só funciona para um registro de entrada; o cabeçalho é usado para imprimir tudo em um link tio.

$\=' __ 
/  \
\__/'   # output record separator initialized with hexagon (size 1)

s/_+/__$&/g,s/^|$/ /gm,s/^ *\S /$& /gm,s-( +)\\ -$&/ $1 \\ \\ $1 /
- # regexes to increase the hexagon by 1

for .. --$_ # to repeat n-1 times where n is the input

Answer 6

Haskell , 150 bytes

r=reverse
m(o:c:k)=o:c:c:c:k++" "
f 1=[["\\  /","__ "],["/__\\"]]
f n|[w:i,j]<-map m<$>f(n-1),_:_:k<-r$m w=[r k:w:i,k:j]
h[i,j]=unlines$r<$>r i++j
h.f

Experimente online!

Uma versão mais recursiva desta resposta. A arbitrariedade desse desafio torna isso muito frustrante.

Explicação

Essa resposta é um pouco difícil de explicar. O desafio é, como já disse, arbitrário em alguns aspectos, então o código é uma espécie de ninho de símbolos.

Idéia

A ideia do programa aqui é construir as duas metades. Isto é, ao calcular o enésimo hexágono, obtemos as duas metades para o hexágono n-1 e usamos isso para fazer o próximo maior.

No entanto, existem algumas ressalvas. Construímos a metade superior de cima para baixo e as duas metades espelhadas da esquerda para a direita. Fazemos isso porque é conveniente fazer dessa maneira. Não há nenhuma razão profunda para apenas tornar as coisas mais curtas, mesmo que as torne um pouco incompreensíveis.

Detalhes

A primeira linha é bastante direta ré um apelido para reverse. A segunda linha não é tão direta. mé uma função sem sentido, ela existe porque ela ou uma operação semelhante precisa ser realizada em alguns lugares. Realmente não tem um significado semântico. A melhor explicação do que ele faz aqui é o código.

m(o:c:k)=o:c:c:c:k++" "

A partir daqui, começamos a ver fquem trata basicamente de toda a lógica. O primeiro caso fé o caso básico, é bastante padrão

f 1=[["\\  /","__ "],["/__\\"]]

Observe que retornamos uma lista de dois itens em vez de uma tupla. Em qualquer programa lógico, usaríamos uma tupla, pois ela é fixada em 2 elementos. No entanto, mais tarde, mapearemos ambos os argumentos com a mesma função. É difícil fazer isso com uma tupla, mas fácil com uma lista, e a lista não apresenta nenhuma desvantagem, então a usamos.

Então temos o caso indutivo. Primeiro, buscamos o caso anterior e mapeamos duas vezes msobre ele. Isso torna o hexágono 1 unidade mais largo (2 caracteres) e move-o meia unidade (1 caractere) para a direita (embora, como tudo está para trás, os caracteres de espaço sejam adicionados à direita ). Nós combinamos isso com o padrão [w:i,j]porque queremos usar wpara fazer novas linhas posteriormente. Falando nisso a seguir fazemos as linhas. Fazemos isso com uma correspondência de padrão:

_:_:k<-r$m w

Este é um tipo de código sem sentido. Ele apenas junta coisas que já tínhamos para produzir a saída correta. ke seu reverso forma as novas linhas, então nós as adicionamos e retornamos isso.

Depois f, temos hque transforma a saída de fem uma string. Ele desfaz todas as transformações malucas que usamos durante a construção e empacota para ser usado.

Com tudo isso acabamos de compor fe hpara a função final.

Answer 7

Haskell , 100 bytes

f n=unlines[q<$>[1..3*n]++[1-n..0]|y<-[-n..n],let q x|abs y==n,x>n='_'|x==y='\\'|x+y==1='/'|1>0=' ']

Experimente online!

A resposta do golfe AZTECCO mais algumas técnicas novas.

A ideia principal é que o hexágono fica mais simples se transplantarmos as primeiras ncolunas para o final.

|-|
   ______   
  /      \  
 /        \ 
/          \
\          /
 \        / 
  \______/  

         |-|
______      
      \    /
       \  / 
        \/  
        /\  
       /  \  
______/    \

Agora todos os /e \estão em uma única linha e _estão todos à esquerda deles. Isso torna muito mais fácil fazer a estratégia do AZTECCO de determinar o caractere da coordenada. Para implementar essas coordenadas renomeadas, substituímos as xcoordenadas- [1..4*n]por uma versão alternada e deslocada [1..3*n]++[1-n..0].

Answer 8

Retina 0.8.2 , 94 bytes

.+
$* ¶$&$* \G ¶$%'/$`$%_$%_$`\
r` \G
$%`\$'$%_$%_$%'/¶ ^¶( *) $1 $.&$*_$.&$*_$& T` `\_` +/$

Experimente online! O link inclui casos de teste. Explicação:

.+
$* ¶$&$* 

Insira duas linhas de nespaços.

\G 
¶$%'/$`$%_$%_$`\

Converta a primeira linha nos lados superiores do hexágono.

r` \G
$%`\$'$%_$%_$%'/¶

Converta a segunda linha nos lados inferiores do hexágono.

^¶( *)
$1 $.&$*_$.&$*_$&

Insira a linha superior.

T` `\_` +/$

Substitua a linha de fundo.

Answer 9

Python 2 , 119 114 bytes

i=n=input()
d=0
exec"k=i/n|d;print' '*i+'\_/'[~k]+'_ '[i-d<n]*2*(2*n+~i)+'\_/'[k]\nif i==d:d=i=-1\ni-=d|1;"*(n-~n)

Experimente online!

Answer 10

JavaScript (ES6),  109  107 bytes

w=>(x=0,W=w*4,i=g=y=>~y?`
 /\\_`[x++-W?y*!i|w/x|x>w*3?(x+~y+w)%W?(x+y)%W-w?1:3:2:4:x=i=0&y--]+g(y):'')(w*2)

Experimente online!

Comentado

w => (                        // w = input
  x = 0,                      // initialize x to 0
  W = w * 4,                  // W = total width
  i =                         // initialize i to a non-zero value
  g = y =>                    // g is a recursive function taking y
  ~y ?                        //   if y is not equal to -1:
    `\n /\\_`[                //     list of characters
      x++ - W ?               //     if this is not the end of the row:
        y * !i |              //       if this is neither the first nor the last row
        w / x |               //       or x is less than or equal to w
        x > w * 3 ?           //       or x is greater than w * 3:
          (x + ~y + w) % W ?  //         if (x - y - 1 + w) mod W is not equal to 0:
            (x + y) % W - w ? //           if (x + y) mod W is not equal to w:
              1               //             draw a space
            :                 //           else:
              3               //             draw a '\'
          :                   //         else:
            2                 //           draw a '/'
        :                     //       else:
          4                   //         draw a '_'
      :                       //     else:
        x = i = 0 & y--       //       decrement y, set x and i to 0 and draw a linefeed
    ] + g(y)                  //     append the result of a recursive call
  :                           //   else:
    ''                        //     stop the recursion
)(w * 2)                      // initial call to g with y = w * 2

Answer 11

C (gcc) , ^{194 \$\cdots\$ 149} 144 bytes

Salvou 13 14 19 bytes graças ao tetocat !!!

p(n,c){for(;n--;)printf(L"/\\ _\n"+c);}i;t;f(n){p(n,2);for(i=t=p(2*n,3);i>=p(1,4);t=i/n?--i,1:t)i+=!p(!p(n+i<<!p(!p(n+~i,2),t),t&!i|2),!t)-2*t;}

Experimente online!

Explicação (antes de alguns jogos de golfe)

p(n,c){for(;n--;)                     // Helper function to print  
         putchar("/\\ _\n"[c]);}      //  one of '/', '\', ' ', '_' , or  
                                      //  newline n times, this function  
                                      //  also returns 0 
i;t;f(n){                             // Main function prints an n hexagon  
        p(n,2);                       // Print n leading spaces for the 1st  
                                      //  line 
        for(                          // Main loop
            i=t=p(2*n,3);             // Set i and t to 0,  
                                      //  and print 2*n '_'s for the 1st line
            i>=p(1,4);                // Loop until i goes below 0, and 
                                      //  print a newline
                                      // At the end of each loop:  
            i+=1-2*t,                 //  increment i for the 1st half  
                                      //   and then decrement i in the 2nd  
            t=i/n?--i,1:t)            //  keep t as t unless i equals n,   
                                      //  then make t 1 and decrement i   
                                      // In the main loop:
                p(n+~i,2),            //  print n-i-1 leading spaces     
                p(1,t),               //  print a '/' in the 1st half and a  
                                      //   '\' in the 2nd    
                p(n+i<<1,t&!i|2),     //  print the 2*(n+i) middle spaces  
                                      //   unless at the bottom print '_'s  
                p(1,!t);              //  print a '\' in the 1st half and a  
                                      //   '/' in the 2nd    
   }  
 

Answer 12

05AB1E , 33 29 25 bytes

-4 ( 7 ) bytes graças a Kevin Cruijssen !

L+<'/úíºI·'_ך»∊¶¡`ðs‡).c

Experimente online!

05AB1E tem um builtin lona que pode ser útil, mas é bastante complicado para começar a trabalhar, este é apenas o builtins espelho ºe ∊e o builtin centralize .c.

Answer 13

J , ⁵⁰ 47 bytes

-3 graças a Jonas!

' \/_'{~]|."1((0,]+2*|.)@=@i.,.3,3,~0$~<:,])@+:

Experimente online!

((0,]+2*|.)@=@i.  ,.  3,3,~0$~<:,])@+:
     0 0 0 0            3 3 3 3
     1 0 0 2            0 0 0 0
     0 1 2 0            0 0 0 0
     0 2 1 0            0 0 0 0
     2 0 0 1            3 3 3 3

    ]|."1
0 0 3 3 3 3 0 0
0 2 0 0 0 0 1 0
2 0 0 0 0 0 0 1
1 0 0 0 0 0 0 2
0 1 3 3 3 3 2 0

' \/_'{~ 
  ____
 /    \    
/      \    
\      /  
 \____/  

Answer 14

Python 3.8 (pré-lançamento) , 174 bytes

n=int(input())
b,a,s="\/ "
z,f=range(n),lambda c,d,t:((n-1-i)*s+c+2*(n+i)*s+d for i in t)
print(f"{'_'*2*n:^{4*n}}",*f(a,b,z),*f(b,a,z[:0:-1]),f"{b:>{n}}{'_'*2*n}/",sep="\n")

Experimente online!

-1 byte graças a @Duncan

-8 bytes graças a @Danis

Answer 15

Haskell , 129 120 bytes

g=mod
f n|a<-n*4=[c|y<-[-n..n],x<-[0..a],let c|x<1='\n'|g x(n*3+1)>n,abs y==n='_'|g(x+y)a==1='/'|g(x-y)a<1='\\'|1>0=' ']

Experimente online!

• economizou 9 graças ao @Wheat Wizard e @xnor.

• Verifique a resposta do @xnor e sua grande melhoria na abordagem do problema (evitando módulo e linhas paralelas)!

• Equivalente à minha resposta C

Fazemos coordenadas cartesianas usando compreensão de lista | y <- [0..n * 2], x <- [0..a]

[c | ..., deixe c | ... | ... | ...] e nós fornecemos o caractere necessário com base em xy ou x + y para desenhar linhas ..
Usamos o módulo para desenhar várias linhas (2)
O caso especial é para o _qual não precisa da razão ax / y, mas um intervalo, nós usei o módulo para fazer apenas uma comparação em >vez de um a> x> b como

Answer 16

Ruby , 141 bytes

->(n,g=->c,d{(1..n).map{|i|" "*(n-i)+d+" "*2*(n+i-1)+c}},l=g[?/,e=?\\].reverse){[" "*n+?_*n*2,g[e,?/],l[0..-2],l[-1].sub(/ +(?=\/)/,?_*n*2)]}

Experimente online!

Se um sublinhado superior for permitido, ele ocupará bytes um pouco menores, enquanto o hexágono é tão bonito quanto era antes ;-)

Ruby , 114 bytes

->n{[" "*n+?_*2*n,(g=->c,d{(1..n).map{|i|" "*(n-i)+c+" "*2*(n+i-1)+d}})[?/,e=?\\],g[e,?/].reverse," "*n+?‾*n*2]}

Experimente online!

Answer 17

05AB1E , 70 bytes

ðש'_¹·×«©¶«©¹'/1Λ¹·Ì'.2Λ¹'\3.Λ«©„./`.;©¶¡Â‚€»`s'.ð:,¹3*>(£„._`:„/\‡,

Experimente online!

Answer 18

Perl 5 , 143 bytes

sub f{$n=pop;@b=map{join'',$"x($n-$_),'/','  'x($n+$_-1),'\\',$/}1..$n;join('',$"x$n,$u=__ x$n,$/,@b,map y|/\\|\\/|r,reverse@b)=~s| +/$|$u/|sr}

Experimente online!

sub f{
  $n=pop;             #n = input
  @b=map{             #set array @b to line 2 - n+1
    join'',           #join parts into a line string
    $" x ($n-$_), #space times n-1 '/', #char / ' ' x ($n+$_-1), #space times n+iterator minus 1 '\\', #char \ $/                #char newline
  } 1..$n; #n lines join('', #return string of these joined: $" x $n, #n spaces $u = __ x$n, #n*2 underscores $/,               #char newline
    @b,               #lines 2 to n+1 constructed above
    map y|/\\|\\/|r,  #and bottom part which is the same
      reverse@b       #as top part reversed and /\ rotated
  )=~s| +/$|$u/|sr    #and change last spaces of last line to _'s
}

Answer 19

Haskell , 186 168 bytes

-18 bytes com correções de xnor e remoção de espaços desnecessários na última linha

s=' '
(!)=replicate
e=reverse
h n=unlines$(\m->(n!s++(2*n)!'_'++n!s):e(e<$>m)++init m++[(n-1)!s++'\\':(2*n)!'_'++"/"])$(\i->i!s++'\\':(4*n-2*i-2)!s++'/':i!s)<$>[0..n-1]

Experimente online!

Ungolfed:

hex :: Int -> String
hex n = unlines $ first: middle ++ (init $ reverse (map reverse middle)) ++ [last]
  where
    first = replicate n ' ' ++ replicate (2*n) '_' ++ replicate n ' '
    f i = replicate i ' ' ++ "/" ++ replicate (n-i + 2*n + n-i -2) ' ' ++ "\\" ++ replicate i ' '
    middle = map f [n-1,n-2..0]
    last = replicate (n-1) ' ' ++ "\\" ++ replicate (2*n) '_' ++ "/" ++ replicate (n-2) ' '