Erstellen Sie einen Wirbel!

10

Ihre heutige Mission ist es, einen Wirbel mit einem einzigen Parameter zu erzeugen.

Dieser Parameter bestimmt die Länge jedes Arms in Zeichen.

Jede "Schicht" jedes Arms enthält ein Zeichen mehr als die letzte.

So sieht der Wirbel bei gegebener Armlänge aus:

0:

#

1:

 # 
###
 # 

2:

 #
  # #
 ### 
# #  
   #

3:

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

4:

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

10:

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

Es gelten Standardlücken, nachfolgendes Leerzeichen optional. Jedes einzelne Nicht-Leerzeichen in ASCII kann "#" ersetzen.

Dies ist also gewinnt die kürzeste Antwort in Bytes.

Papayaman1000
quelle
Die Spezifikation (wie es sie gibt) scheint den Beispielen zu widersprechen. Woher kam die Asymmetrie in den letzten beiden?
Peter Taylor
Hier ist eine korrigierte Version.
Rahnema1
@ JonathanAllan siehe Beschreibung meiner Bearbeitung: Das hässliche schwarze Nicht-Zeichen wurde entfernt, aber sie sind immer noch asimmetrisch . Und nein, ich übernehme nicht ... Scheint mir eine langweilige Herausforderung zu sein (keine Beleidigung)
Mr. Xcoder
Bitte öffnen Sie dies erneut. Es ist jetzt klar.
Programmierer5000
1
@ JonathanAllan Ja, sie hatten ein Problem, wie Sie sagten. Fest.
Papayaman1000

Antworten:

5

MATL , 60 Bytes

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

Probieren Sie es online aus! Oder überprüfen Sie die Testfälle: 0 , 1 , 2 , 3 , 4 , 10 .

Es stellte sich heraus, dass dies lustiger war als ich erwartet hatte. Erklären wird allerdings schwieriger ...

Luis Mendo
quelle
3

Gelee , 48 Bytes

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

Probieren Sie es online aus!

(Macht es mehr Platz , der von den endgültigen Ersetzen Ymit G, um einen Raum zwischen jeder Spalte hinzuzufügen).

Wie?

Erstellt eine Liste der #Koordinaten eines Arms relativ zur Mitte. Transformiert dies in die Koordinaten der vier Arme von der oberen linken Ecke und fügt die Mittelkoordinate hinzu. Erstellt eine Tabelle mit allen Koordinaten im Raum und setzt die Arme #und den Raum auf und verbindet die Zeilen mit Zeilenumbrüchen.

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
Jonathan Allan
quelle
0

Mathematica 139 172 Bytes

Die Idee ist, einen einzelnen Arm mit einer Funktion zu erstellen {⌊.5+.5(-7+8#)^.5⌋,#-1}, die den Index jedes Elements des Arms ausspuckt, vorausgesetzt, das mittlere Element hat den Index (0,0). Das hat noch niemand aufgegriffen, aber ich vermute, dass diese Idee zu einer gewinnbringenden Antwort in einer besseren Golfsprache führen würde. Dann drehe ich den Arm um ein Vielfaches von 90 Grad, indiziere neu und konstruiere die Matrix.

SparseArrayschien die offensichtliche Wahl für die Konstruktion der Matrix zu sein, hätte aber mit BoxMatrixund gehen können 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 (hart codiert für Armlänge = 3, %bedeutet vorherige Ausgabe):

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

Verwendung% @ 4

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

Wie ich erfahren habe, muss die Ausgabe reines ASCII ohne zusätzlichen Abstand oder Formatierung sein, der Code muss etwas länger werden (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",""]

#     #  
 ##  #   
   # #   
  ###    
 # #     
 #  ##   
#     #  
Kelly Lowder
quelle
Kann der zusätzliche Abstand zwischen den Spalten entfernt werden? Da dies eine ASCII-artige Herausforderung ist, sollte die Ausgabe genau wie angegeben sein, ohne zusätzlichen Abstand (@ Papayaman1000, bitte bestätigen Sie, ob dies ausgenommen werden kann)
HyperNeutrino
Ich habe dafür eine Bearbeitung vorgenommen, wenn sich herausstellt, dass dies erforderlich ist. Im Moment scheint es umstritten.
Kelly Lowder
Hmm ... Ich würde es vorziehen, wenn Sie aus Gründen des Wettbewerbs die Antwort verwenden, die die genaue Ausgabe liefert. Wie @HyperNeutrino sagte, handelt es sich um ASCII-Kunst, daher sollte es wie angegeben sein.
Papayaman1000
OK, ich habe es behoben.
Kelly Lowder
0

Holzkohle , 30 Bytes

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

Erläuterung

#                                    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

Probieren Sie es online aus!

Nur ASCII
quelle
Trimscheint Golfspieler zu funktionieren: NθFθ⁺¶#×#ιJ⁰¦⁰Tθ⁺¹θ#⟲O↖²⁴⁶( ⁺¹ist eine Problemumgehung, weil T⁰¦⁰sie aus irgendeinem Grund nicht funktioniert und damals nicht existierte.)
Neil