Nhiệm vụ của bạn hôm nay là tạo ra một cơn lốc với một tham số duy nhất.

Tham số này xác định chiều dài của mỗi cánh tay tính bằng ký tự.

Mỗi "lớp" của mỗi cánh tay chứa một ký tự nhiều hơn ký tự cuối cùng.

Đây là hình dạng của cơn lốc, với chiều dài cánh tay:

0:

#

1:

 # 
###
 # 

2:

 #
  # #
 ### 
# #  
   #

3:

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

4:

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

10:

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

Các lỗ hổng tiêu chuẩn được áp dụng, theo dõi khoảng trắng tùy chọn, bất kỳ ký tự không phải khoảng trắng nào trong ASCII đều có thể thay thế "#".

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

MATL , 60 byte

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

Hãy thử trực tuyến! Hoặc xác minh các trường hợp kiểm tra: 0 , 1 , 2 , 3 , 4 , 10 .

Điều này hóa ra là buồn cười hơn tôi mong đợi. Giải thích sẽ khó hơn, mặc dù ...

Thạch , 48 byte

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

Hãy thử trực tuyến!

(Làm cho tất cả vuông hơn bằng cách thay thế cuối cùng Ybằng G, thêm khoảng trắng giữa mỗi cột).

Làm sao?

Xây dựng một danh sách #tọa độ của một cánh tay so với trung tâm. Biến đổi nó thành tọa độ của bốn cánh tay từ góc trên bên trái và thêm tọa độ trung tâm. Xây dựng một bảng gồm tất cả các tọa độ trong không gian và đặt các cánh tay #và không gian để và nối các hàng với các dòng mới.

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

Toán học 139 172 byte

Ý tưởng là tạo ra một cánh tay duy nhất có chức năng - {⌊.5+.5(-7+8#)^.5⌋,#-1}phun ra chỉ số của từng phần tử của nhánh với giả định phần tử ở giữa có chỉ số (0,0). Chưa ai nhận ra điều đó, nhưng tôi nghi ngờ ý tưởng này sẽ dẫn đến một câu trả lời chiến thắng trong một ngôn ngữ chơi golf tốt hơn. Sau đó, tôi xoay cánh tay thông qua bội số 90 độ, lập chỉ mục lại và xây dựng ma trận.

SparseArraycó vẻ như là sự lựa chọn rõ ràng để xây dựng ma trận, nhưng có thể đã đi cùng BoxMatrixvà 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 (Mã hóa cứng cho chiều dài cánh tay = 3, %có nghĩa là đầu ra trước đó):

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

Sử dụng% @ 4

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

Vì tôi đã học được đầu ra phải là ASCII thuần túy mà không cần thêm khoảng cách hoặc định dạng, mã phải dài hơn một chút (172 byte):

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

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

Than , 30 byte

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

Giải trình

#                                    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

Hãy thử trực tuyến!