今日のあなたの使命は、単一のパラメーターを指定して渦を作成することです。

このパラメーターは、各腕の長さを文字数で決定します。

各腕の各「レイヤー」には、最後の腕よりも1つ多い文字が含まれています。

アームの長さが与えられた場合の渦の様子は次のとおりです。

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

オンラインでお試しください！

（最後の文字列をに置き換え、各列の間にスペースを追加YしてG、四角形にします）。

どうやって？

#中心を基準にした腕の座標のリストを作成します。左上隅から4本の腕の座標に変換し、中心座標を追加します。空間の座標のすべてのテーブルを構築し、への武器セット#とのスペースを改行で行を結合します。

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

Mathematicaの139の 172バイト

アイデアは、関数を使用して単一のアームを作成する{⌊.5+.5(-7+8#)^.5⌋,#-1}ことです。これにより、中央の要素がインデックス（0,0）であると想定して、アームの各要素のインデックスを吐き出します。まだ誰もそれを取り上げていませんが、この考えがより良いゴルフ言語での勝利の答えをもたらすと私は思います。次に、腕を90度単位で回転させ、インデックスを再作成してマトリックスを作成します。

SparseArrayは、行列を作成するための明らかな選択のように見えましたが、BoxMatrixおよびを使用することもできます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

オンラインでお試しください！