Crie um vórtice!


10

Sua missão hoje é criar um vórtice com um único parâmetro.

Este parâmetro determina o comprimento de cada braço em caracteres.

Cada "camada" de cada braço contém mais um caractere que o anterior.

Aqui está como o vórtice ficará, considerando o comprimento do braço:

0:

#

1:

 # 
###
 # 

2:

 #
  # #
 ### 
# #  
   #

3:

##  #
  # #
 ### 
# #  
#  ##

4:

#     #
 ##  #
   # #
  ###  
 # #   
 #  ## 
#     #

10:

             #
             #
             #     
             #   
            #      
####        #      
    ###     #      
       ##  #      
         # #       
        ###       
       # #         
       #  ##       
      #     ###    
      #        ####
      #            
     #             
     #             
     #             
     #             

Aplicam-se brechas padrão, espaço em branco à direita opcional, qualquer caractere não-espaço em branco no ASCII pode substituir "#".

Isso é então a resposta mais curta em bytes vence.


A especificação (como existe) parece contradizer os exemplos. De onde veio a assimetria nos dois últimos?
Peter Taylor

Aqui está uma versão corrigida.
precisa saber é o seguinte

@ JonathanAllan, veja a descrição da minha edição: Removido o feio não-personagem preto, mas eles ainda são assimétricos . E não, eu não estou tomando ... Parece um desafio chato para mim (sem ofensa)
Mr. Xcoder

Por favor, reabra isso. Está claro agora.
programmer5000

11
@ JonathanAllan Sim, eles tiveram um problema como você disse. Fixo.
usar o seguinte comando

Respostas:


5

MATL , 60 bytes

3<G+Eqt&OlG8M+t&(1G:8*X^Q2/kG+G:Gq+&vG2=+Z{(XJ3:"J@X!+]g35*c

Experimente online! Ou verifique os casos de teste: 0 , 1 , 2 , 3 , 4 , 10 .

Isso acabou sendo mais engraçado do que eu esperava. Porém, explicar será mais difícil ...


3

Gelatina , 48 bytes

Rȯ1ĖŒṙ‘Ė’ḣµ;NµN0¦€U;
Ç+;ẋ2W$+⁸<3¤µFṀR,þ$e€€ị⁾# Y

Experimente online!

(Deixe tudo mais quadrado, substituindo a final Ypor G, adicionando um espaço entre cada coluna).

Como?

Constrói uma lista de #coordenadas de um braço em relação ao centro. Transforma isso nas coordenadas dos quatro braços no canto superior esquerdo e adiciona a coordenada central. Cria uma tabela de todas as coordenadas no espaço e define os braços #e o espaço para e une as linhas com novas linhas.

Rȯ1ĖŒṙ‘Ė’ḣµ;NµN0¦€U; - Link 1, arm coordinates relative to centre: arm-length a
R                    - range: [1,2,...,a]
 ȯ1                  - or 1 (stops Œṙ erroring with arm-length 0; builds no redundant coordinates in the end)
   Ė                 - enumerate: [[1,1],[2,2],...[a,a]]  (or [[1,1]] if a=0)
    Œṙ               - run-length decode: [1,2,2,...,a,a,...,a] (or [1] if a=0)
      ‘              - increment: [2,3,3,...,a+1,a+1,...,a+1] (or [2] if a=0)
       Ė             - enumerate: [[1,2],[2,3],...,[T(a)-a,a+1],[T(a)-a+1,a+1],...,[T(a),a+1]] where T(a)=(a+1)*a/2 (or [[1,2]] if a=0)
        ’            - decrement: [[0,1],[1,2],...,[T(a)-a-1,a],[T(a)-a,a],...a[T(a)-1),a]] (or [[0,1]] if a=0)
         ḣ           - head to a (first a of those) - these are an arm's relative coordinates from the central `#` at [0,0])
          µ          - monadic chain separation (call that list r)
           ;         - r concatenated with
            N        - negate r (gets the opposite arm)
             µ       - monadic chain separation (call that list s)
                 €   - for €ach coordinate pair in s:
               0¦    -     apply to index 0 (the right of the two values):
              N      -         negate
                  U  - upend (reverse each pair of that, gives the other two arms)
                   ; - concatenate that list with s (gives all four arms)

Ç+;ẋ2W$+⁸<3¤µFṀR,þ$e€€ị⁾# Y - Main link: arm-length a
Ç                           - call the last link(1) as a monad (get centre-relative coordinates)
 +                          - add a (make the coordinates relative to the top-left)
      $                     - last two links as a monad:
   ẋ2                       -     repeat a twice: [a,a]
     W                      -     wrap in a list: [[a,a]] (the centre coordinate)
  ;                         - concatenate (add the centre coordinate)
           ¤                - nilad followed by link(s) as a nilad:
        ⁸                   -     link's left argument, a
         <3                 -     less than three?
       +                    - add (a in 0,1,2 are special cases requiring a grid one-by-one more than all the rest)
            µ               - monadic separation (call that c)
             F              - flatten c into one list
              Ṁ             - get the maximum (the side-length of the space)
                  $         - last two links as a monad:
               R            -     range: [1,2,...,side-length]
                ,þ          -     pair table: [[[1,1],[1,2],...,[1,side-length]],[[2,1],[2,2],...,[2,side-length]],...,[[side-length,1],[side-length,2],[side-length, side-length]]]
                   e€€      - exists in c? for €ach for €ach (1 if a # coordinate, 0 otherwise)
                       ⁾#   - literal ['#',' ']
                      ị     - index into
                          Y - join with new line characters
                            - implicit print

0

Mathematica 139 172 Bytes

A idéia é criar um único braço com uma função - {⌊.5+.5(-7+8#)^.5⌋,#-1}que cospe o índice de cada elemento do braço, assumindo que o elemento do meio tenha índice (0,0). Ninguém entendeu ainda, mas suspeito que essa idéia resultaria em uma resposta vencedora em um idioma melhor para o golfe. Então eu giro o braço através de múltiplos de 90 graus, re-indexo e construo a matriz.

SparseArrayparecia a escolha óbvia para a construção da matriz, mas poderia ter sido com BoxMatrixe ReplacePart.

Grid[SparseArray[Max@#+#+1&[Join@@Table[RotationMatrix[i Pi/2].#&/@{{0,0}}~Join~Array[{⌊.5+.5(-7+8#)^.5⌋,#-1}&,#],{i,4}]]->X,2#+1,""]]&

Ungolfed (codificado para comprimento do braço = 3, %significa saída anterior):

{{0,0}}~Join~Table[{Floor[1/2 (1+Sqrt[-7+8x])],x-1},{x,1,3}]
Table[RotationMatrix[i Pi/2].#&/@%,{i,4}]
Flatten[%,1]
Max[%]+%+1
Normal@SparseArray[%->X,Automatic,""]
Grid[%/. 0->""]

Uso% @ 4

X                       X   
    X   X           X       
            X       X       
        X   X   X           
    X       X               
    X           X   X       
X                       X

Como aprendi que a saída deve ser pura ASCII sem espaçamento ou formatação extra, o código precisa ficar um pouco mais longo (172 bytes):

StringRiffle[ReplacePart[Array[" "&,{1,1}*2#+1],Max@#+#+1&[Join@@Table[RotationMatrix[i Pi/2].#&/@{{0,0}}~Join~Array[{⌊.5+.5(-7+8 #)^.5⌋,#-1}&,#],{i,4}]]->"#"],"\n",""]

#     #  
 ##  #   
   # #   
  ###    
 # #     
 #  ##   
#     #  

O espaçamento extra entre as colunas pode ser removido? Como este é um desafio ASCII-art, a saída deve ser exatamente como especificado, sem espaço extra (@ Papayaman1000 Por favor, confirme se este pode ser isento)
HyperNeutrino

Coloquei uma edição para isso, se for necessário. Neste momento, parece discutível.
Kelly Lowder

Hmm ... eu preferiria que, pelo bem da concorrência, você usasse a resposta que fornece a saída exata. Como o @HyperNeutrino disse, é arte ASCII, portanto deve ser o especificado.
usar o seguinte comando

OK, eu consertei.
Kelly Lowder

0

Carvão , 30 bytes

#NβFβ«¿ι«×#⌊⟦ιβ⟧A⁻βιβ↑»»‖←⟲O²⁴⁶

Explicação

#                                    Print "#"
 Nβ                                 Input number to b
    Fβ«                  »          For i in range(b)
        ¿ι«              »           If i is truthy (to skip 0)
           ×#⌊⟦ιβ⟧                   Print "#" * minimum of i and b
                  A⁻βιβ↑            Assign b-i to b
                           ‖         Reflect right
                            ⟲O²⁴⁶  Rotate overlap 90, 180 and 270 degrees

Experimente online!


Trimparece funcionar Golfier: NθFθ⁺¶#×#ιJ⁰¦⁰Tθ⁺¹θ#⟲O↖²⁴⁶( ⁺¹é uma solução porque T⁰¦⁰não funciona por algum motivo e. não existia naquela época.)
Neil
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.