Créez un vortex!

10

Votre mission aujourd'hui est de créer un vortex avec un seul paramètre.

Ce paramètre détermine la longueur de chaque bras en caractères.

Chaque "couche" de chaque bras contient un caractère de plus que le dernier.

Voici à quoi ressemblera le vortex, compte tenu de la longueur du bras:

0:

#

1:

 # 
###
 # 

2:

 #
  # #
 ### 
# #  
   #

3:

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

4:

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

10:

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

Les failles standard s'appliquent, les espaces à la fin facultatifs, tout caractère non blanc en ASCII peut remplacer "#".

Il s'agit de donc la réponse la plus courte en octets l'emporte.

Papayaman1000
la source
La spécification (telle qu'elle existe) semble contredire les exemples. D'où vient l'asymétrie des deux derniers?
Peter Taylor
Voici une version corrigée.
rahnema1
@JonathanAllan voir la description de ma modification: Suppression du non-caractère laid noir, mais ils sont toujours asymétriques . Et non, je ne prends pas la relève ... Cela me semble être un défi ennuyeux (pas d'offense)
M. Xcoder
Veuillez le rouvrir. C'est clair maintenant.
programmer5000
1
@JonathanAllan Oui, ils ont eu un problème comme vous l'avez dit. Fixé.
Papayaman1000

Réponses:

5

MATL , 60 octets

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

Essayez-le en ligne! Ou vérifiez les cas de test: 0 , 1 , 2 , 3 , 4 , 10 .

Cela s'est avéré plus drôle que ce à quoi je m'attendais. Expliquer va être plus difficile, cependant ...

Luis Mendo
la source
3

Gelée , 48 octets

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

Essayez-le en ligne!

(Rendez le tout plus carré en remplaçant la finale Ypar G, en ajoutant un espace entre chaque colonne).

Comment?

Construit une liste de #coordonnées d'un bras par rapport au centre. Transforme cela aux coordonnées des quatre bras à partir du coin supérieur gauche et ajoute la coordonnée centrale. Construit un tableau de toutes les coordonnées dans l'espace et définit les bras #et l'espace sur et joint les lignes avec des retours à la ligne.

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
la source
0

Mathematica 139 172 octets

L'idée est de créer un seul bras avec une fonction - {⌊.5+.5(-7+8#)^.5⌋,#-1}qui crache l'index de chaque élément du bras en supposant que l'élément du milieu a un index (0,0). Personne n'a encore compris cela, mais je pense que cette idée entraînerait une réponse gagnante dans une meilleure langue de golf. Ensuite, je fais pivoter le bras sur des multiples de 90 degrés, je ré-indexe et je construis la matrice.

SparseArraysemblait être le choix évident pour construire la matrice, mais aurait pu aller avec BoxMatrixet 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,""]]&

Non golfé (codé en dur pour la longueur du bras = 3, %signifie la sortie précédente):

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

Utilisation% @ 4

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

Comme j'ai appris que la sortie doit être pure ASCII sans espacement ni formatage supplémentaire, le code doit être un peu plus long (172 octets):

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
la source
L'espacement supplémentaire entre les colonnes peut-il être supprimé? Comme il s'agit d'un défi ASCII, la sortie doit être exactement comme spécifiée, sans espacement supplémentaire (@ Papayaman1000, veuillez confirmer si cela peut être exempté)
HyperNeutrino
Je mets un montage pour ça s'il s'avère nécessaire. En ce moment, cela semble discutable.
Kelly Lowder
Hmm ... Je préférerais que, pour la compétition, vous utilisiez la réponse qui donne la sortie exacte. Comme l'a dit @HyperNeutrino, c'est de l'art ASCII, donc il devrait être comme spécifié.
Papayaman1000
OK, je l'ai réparé.
Kelly Lowder
0

Fusain , 30 octets

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

Explication

#                                    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

Essayez-le en ligne!

ASCII uniquement
la source
Trimsemble fonctionner sur golfier: NθFθ⁺¶#×#ιJ⁰¦⁰Tθ⁺¹θ#⟲O↖²⁴⁶( ⁺¹est une solution de contournement car T⁰¦⁰ne fonctionne pas pour une raison quelconque. et n'existait pas à l'époque.)
Neil