오늘 당신의 임무는 단일 매개 변수가 주어진 소용돌이를 만드는 것입니다.

이 매개 변수는 각 팔의 길이를 문자로 결정합니다.

각 팔의 각 "레이어"에는 마지막 것보다 하나 이상의 문자가 포함됩니다.

팔 길이를 고려하여 소용돌이가 어떻게 보이는지 다음과 같습니다.

0:

#

1:

 # 
###
 # 

2:

 #
  # #
 ### 
# #  
   #

3:

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

4:

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

10:

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

표준 허점은 적용되며 후행 공백은 선택 사항이며 ASCII의 공백이 아닌 단일 문자는 "#"을 대체 할 수 있습니다.

이것은 코드 골프 이므로 바이트 단위의 최단 답변이 이깁니다.

MATL , 60 바이트

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

온라인으로 사용해보십시오! 또는 테스트 케이스를 확인 : 0 , 1 , 2 , 3 , 4 , 10 .

이것은 내가 예상했던 것보다 더 재미 있었다. 그래도 설명은 더 어려워 질 것입니다 ...

젤리 , 48 바이트

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

온라인으로 사용해보십시오!

( 각 열 사이에 공백을 추가 하여 final Y을 로 바꾸어 더 정사각형으로 만드십시오 G).

어떻게?

#중심을 기준으로 팔 의 좌표 목록 을 작성합니다. 왼쪽 위 모서리에서 네 팔의 좌표로 변환하고 중심 좌표를 추가합니다. 공간의 좌표 모든 테이블을 구축하고에 팔 설정 #과에 공간을 줄 바꿈으로 행을 결합한다.

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

매쓰 139 172 바이트

아이디어는 함수를 사용하여 단일 팔을 만드는 것입니다 {⌊.5+.5(-7+8#)^.5⌋,#-1}. 중간 요소에 색인 (0,0)이 있다고 가정하면 팔의 각 요소 색인을 뱉어냅니다. 아직 아무도이 사실을 알지 못했지만이 아이디어가 더 나은 골프 언어로 이길 것이라고 생각합니다. 그런 다음 팔을 90 도의 배수로 회전시키고 다시 색인을 생성하고 행렬을 만듭니다.

SparseArray행렬을 만들기위한 명백한 선택처럼 보였지만 BoxMatrixand 와 함께 갈 수있었습니다 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 (팔 길이 = 3으로 하드 코딩 됨, %이전 출력을 의미) :

{{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->""]

사용량 % @ 4

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

추가 간격이나 서식이없는 출력은 순수한 ASCII 여야한다는 것을 알았으므로 코드는 조금 더 길어야합니다 (172 바이트).

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",""]

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

숯 , 30 바이트

#ＮβＦβ«¿ι«×#⌊⟦ιβ⟧Ａ⁻βιβ↑»»‖←⟲Ｏ²⁴⁶

설명

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

온라인으로 사용해보십시오!