Flèches de tir à l'arc ASCII Art

16

Écrivez un programme ou une fonction qui prend un entier positif et imprime ou renvoie une représentation artistique ASCII d'une flèche de tir à l'arc , mise à l'échelle en fonction de l'entrée.

Si l'entrée est 1la sortie est

  /\
 /  \
 \__/
  ||
  ||
  ||
  ||
  ||
  ||
  ||
  ||
 /||\
/ || \
/ || \
//  \\
/    \

Si l'entrée est 2la sortie est

     /\
    /  \
   /    \
  /      \
  \      /
   \____/
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
    |  |
   /|  |\
  / |  | \
 /  |  |  \
/   |  |   \
/   |  |   \
/   |__|   \
/  /    \  \
/ /      \ \
//        \\
/          \

Si l'entrée est 3la sortie est

        /\
       /  \
      /    \
     /      \
    /        \
   /          \
   \          /
    \        /
     \______/
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
      |    |
     /|    |\
    / |    | \
   /  |    |  \
  /   |    |   \
 /    |    |    \
/     |    |     \
/     |    |     \
/     |    |     \
/     |____|     \
/    /      \    \
/   /        \   \
/  /          \  \
/ /            \ \
//              \\
/                \

Si l'entrée est 4la sortie est

           /\
          /  \
         /    \
        /      \
       /        \
      /          \
     /            \
    /              \
    \              /
     \            /
      \          /
       \________/
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
        |      |
       /|      |\
      / |      | \
     /  |      |  \
    /   |      |   \
   /    |      |    \
  /     |      |     \
 /      |      |      \
/       |      |       \
/       |      |       \
/       |      |       \
/       |      |       \
/       |______|       \
/      /        \      \
/     /          \     \
/    /            \    \
/   /              \   \
/  /                \  \
/ /                  \ \
//                    \\
/                      \

Le modèle continue pour les nombres d'entrée plus importants - la flèche est mise à l'échelle en conséquence.

Notez que pour toute entrée N:

  • La pointe de flèche est un pentagone avec 2 × N traits de soulignement à la base, N barres obliques sur chacun des côtés s'étendant depuis la base, et 2 × N barres obliques sur les deux côtés qui forment la pointe de la flèche.
  • L'arbre (y compris la partie à l'intérieur de l'empennage) se compose de 11 × N lignes de deux barres verticales séparées par 2 × (N-1) espaces. La toute dernière ligne comporte des traits de soulignement au lieu d'espaces.
  • L'effondrement entoure les lignes inférieures 3 × N de l'arbre. Deux lignes de barres obliques 2 × N s'étendent en diagonale vers le bas de chaque côté de l'arbre et sont reliées à des colonnes verticales de barres obliques.
  • La flèche complète mesure 16 × N lignes de haut et 6 × N de large.

Dans votre sortie, il ne devrait pas y avoir de lignes vides avant la pointe de la flèche et seulement jusqu'à un saut de ligne de fin.

Aucune des lignes de sortie ne doit avoir d'espaces de début inutiles (le bord gauche de l'extraction doit être le plus à gauche possible), mais l'une des lignes peut avoir un nombre quelconque d'espaces de fin.

La soumission la plus courte en octets l'emporte.

code-golf ascii-art Loisirs de Calvin
la source
Y a-t-il une taille d'entrée maximale?
Downgoat
1
@vihan Non. Bien que vous puissiez supposer que les nombres ne déborderont pas votre mémoire / entiers.
Calvin's Hobbies
Faut-il s'inquiéter de l'habillage du texte? Pour N> = 14, la taille de fenêtre par défaut sur mon terminal fait que ma flèche ne ressemble pas à une flèche.
kevinsa5
@ kevinsa5 Non. Ne vous inquiétez pas.
Calvin's Hobbies

Réponses:

2

Pyth, 149 147 146 144 146

Edit 2015-9-23: avait un bug, corrigé pour 2 octets. Il pourrait être possible de raccourcir, je n'ai pas le temps maintenant.

Semble encore trop long pour une réponse Pyth.

M*tGHK*11Q=Y*3QA" /"jbC+R*yQG+_Js[ms[*dGHgt-YdG\_gKG\_)tQs[gQGHgyQG\_*K\|)ms[*+QdGH*y-tQdG\\*+*8QydGHgYGH)Qms[*++KQdGHgYGH)tQ+g*13QG*hYH)mXd"\/")J

Explication (presque à jour)

Je génère essentiellement la transposition de la flèche, car son format de ligne est beaucoup plus simple. De plus, je n'en génère qu'une moitié, puis je l'inverse pour économiser beaucoup d'octets.

M*tGH                                                       g(a,b) = (a - 1) * b
A" /"                                                       G = " ", H = "/"
              ms[...)tQ                                     N-1 lines inside body
                       s[...)                               1 line of edge of body
                             ms[...)Q                       N lines of tip + fin
                                     m...Q                  N-1 lines of fin
                                          +...              1 line of edge of fin
            s[                                )             flatten the maps to it
           J                                                save to J
          _                                                 reverse
                                                       J    another copy (unreversed)
                                               mXd"\/")     swap "\" and "/" on each line
         +                                                  add to other half
   +R*yQG                                                   add 2*N spaces to each line
  C                                                         transpose
jb                                                          join by newline

m                             tQ       map d over 0...N-2
 s[                          )         concatenate
   *dG                                 d spaces
      H                                "/"
          =Y*3Q                        save 3*N to Y
       gt-     dG                      3*N-d-2 spaces
                 \_                    "_"
                    K*11Q              save 11*N to K
                   g     G             11*N-1 spaces
                          \_           "_"

s[              )                      concatenate
  gQG                                  N-1 spaces
     H                                 "/"
      gyQG                             2*N-1 spaces
          \_                           "_"
            *K\|                       11*N pipes

m                               Q      map d over 0...N-1
 s[                            )       concatenate
   *+QdG                               N+d spaces
        H                              "/"
         *y-tQdG                       2*(N-d-1) spaces
                \\                     "\"
                  *+*8QydG             8*N+2*d spaces
                          H            "/"
                           gYG         3*N-1 spaces
                              H        "/"

m               tQ                     map d over 0...N-2
 +++                                   concatenate
    *++KQdG                            12*N+d spaces
           H                           "/"
            gYG                        3*N-1 spaces
               H                       "/"

+                                      concatenate
 g*13QG                                13*N-1 spaces
       *hYH                            3*N+1 slashes
PurkkaKoodari
la source
3

Perl, 298 octets

for$y(0..($w=<>)*16-1){$r=$w*3;for$x(0..$w*6-1){$z=$x<$r?$x:$w*6-$x-1,$_.=$z==$r-$y-1&&$y<$w*2||!$z&&$y>=$w*13-1||($z==$w*16-1-$y||$z==$w*13-1-$y)&&$z<$w*2?$x<$r?'/':'\\':$z==$y-$w&&$y>=$w*2&&$y<$r?$x<$r?'\\':'/':$z==$r-$w&&$y>=$r&&$y<$w*14?'|':$z>=$r-$w&&($y==$r-1||$y==$w*14-1)?_:$"}$_.=$/}print

Multi-ligne:

for$y(0..($w=<>)*16-1){$r=$w*3;  # read input and loop over rows
    for$x(0..$w*6-1){  # loop over columns

        # flip x on right side of arrow:
        $z=$x<$r?$x:$w*6-$x-1;

        # slashes on fletching and tip of arrowhead:
        $_.=$z==$r-$y-1&&$y<$w*2||!$z&&$y>=$w*13-1||($z==$w*16-1-$y||$z==$w*13-1-$y)&&$z<$w*2?$x<$r?'/':'\\':

        # slashes on underside of arrowhead:
        $z==$y-$w&&$y>=$w*2&&$y<$r?$x<$r?'\\':'/':

        # vertical bars on side of shaft:
        $z==$r-$w&&$y>=$r&&$y<$w*14?'|':

        # underscores on base of arrowhead and shaft:
        $z>=$r-$w&&($y==$r-1||$y==$w*14-1)?_:$"
   }
   $_.=$/  # add newline at end of each row
}
print  # print out string

Production:

2
     /\     
    /  \    
   /    \   
  /      \  
  \      /  
   \____/   
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
    |  |    
   /|  |\   
  / |  | \  
 /  |  |  \ 
/   |  |   \
/   |  |   \
/   |__|   \
/  /    \  \
/ /      \ \
//        \\
/          \

Merci à Dom Hastings de m'avoir aidé à économiser 5 octets (et à compter)

samgak
la source
1
Hé samgak, vous pouvez économiser quelques octets en déplaçant la $w=<>déclaration à la première fois que vous l'utilisez for$y(0..($w=<>)*16-1){et de nombreux crochets peuvent être supprimés (certains changent la sortie, mais je pense que vous les parcourez quand même!). De plus, vous '_'pouvez simplement être un littéral _. J'espère que cela pourra aider!
Dom Hastings
2

Julia, 452 octets

Cette réponse n'est pas très inspirée, et je ne l'ai pas jouée au-delà de l'évidence flagrante. J'ai l'intention que ce soit un score à battre pour les autres.

function R(c,x,y,e,f,n)
for i=1:n
a[y,x]=c
x+=e
y+=f
end
end
function f(n::Int)
global a=fill(' ',16n,6n)
F='/'
B='\\'
q=3n+1
r=2n+1
R(F,3n,1,-1,1,2n)
R(B,q,1,1,1,2n)
R(B,n+1,r,1,1,n)
R(F,5n,r,-1,1,n)
R('_',r,3n,1,0,2n)
R('|',r,q,0,1,11n)
R('|',4n,q,0,1,11n)
R('_',r+1,14n,1,0,r-3)
R(F,2n,11n+1,-1,1,2n)
R(B,4n+1,11n+1,1,1,2n)
R(F,1,13n,0,1,3n)
R(B,6n,13n,0,1,3n)
R(F,2n,14n+1,-1,1,2n)
R(B,4n+1,14n+1,1,1,2n)
for b = 1:16n
println(join(a[b,:]))
end
end

Essaye le:

julia> f(1)
  /\                          
 /  \                         
 \__/                         
  ||                          
  ||                          
  ||                          
  ||                          
  ||                          
  ||                          
  ||                          
  ||                          
 /||\                         
/ || \                        
/ || \                        
//  \\                        
/    \

non golfé:

# Repeat a character through array a from (x,y) -> (x+n*dx,y+n*dy)
function R(a::Array{Char,2},c::Char, x::Int, y::Int, dx::Int, dy::Int, n::Int)
    for i = 1:n
        a[y,x] = c
        x += dx
        y += dy
    end
end

function arrow(n::Int)
    a = fill(' ',16n,6n)
    # upper left of head
    R(a,'/',3n,1,-1,1,2n)
    # upper right of head
    R(a,'\\',3n+1,1,1,1,2n)
    # lower left of head
    R(a,'\\',n+1,2n+1,1,1,n)
    # lower right of head
    R(a,'/',5n,2n+1,-1,1,n)
    # bottom of head
    R(a,'_',2n+1,3n,1,0,2n)
    # shaft
    R(a,'|',2n+1,3n+1,0,1,11n)
    R(a,'|',4n,3n+1,0,1,11n)
    R(a,'_',2n+2,14n,1,0,2n-2)
    # upper fletching edges
    R(a,'/',2n,11n + 1,-1,1,2n)
    R(a,'\\',4n+1,11n+1,1,1,2n)
    # fletching sides
    R(a,'/',1,13n,0,1,3n)
    R(a,'\\',6n,13n,0,1,3n)
    # lower fletching edges
    R(a,'/',2n,14n + 1,-1,1,2n)
    R(a,'\\',4n+1,14n+1,1,1,2n)
    for r = 1:16n
        println(join(a[r,:]))
    end
end
kevinsa5
la source
2

Rubis, 233

->n{(16*n).times{|i|j=i/n
m=n*3
e=' '*6*n
i%(11*n)==m-1&&e[2*n..4*n-1]=?_*2*n
j%14>2&&e[m+n-1]=e[m-n]=?|
k=(i-n)%m
k<n||j<11||(e[m+k]=?\\;e[m-1-k]=?/)
j>12&&(e[-1]=?\\;e[0]=?/)
j<3&&(e[n+l=(i-n*2)%(n*4)]=?\\;e[5*n-l-1]=?/)  
puts e}}

Je suis particulièrement satisfait de la technique enveloppante que j'ai utilisée pour dessiner tout \dans la tête avec une seule expression (et de même pour /)

Non testé dans le programme de test

f=->n{
  #loop line by line, 0..16*n-1
  (16*n).times{|i|

  #convenience variables
  j=i/n
  m=n*3

  #setup a string of spaces
  e=' '*6*n

  #draw the ___ at top and bottom of shaft
  i%(11*n)==m-1&&e[2*n..4*n-1]=?_*2*n
  #draw the |, overwriting the _ in the bottom corners
  j%14>2&&e[m+n-1]=e[m-n]=?|

  #draw the diagonal fletching
  k=(i-n)%m
  k<n||j<11||(e[m+k]=?\\;e[m-1-k]=?/)

  #draw the ends of the fletching (note index -1, meaning last character in string)
  j>12&&(e[-1]=?\\;e[0]=?/)

  #draw the arrow head, wrapping round with %(n*4)
  j<3&&(e[n+l=(i-n*2)%(n*4)]=?\\;e[5*n-l-1]=?/)

  #output the line  
  puts e}
}

f.call(gets.to_i)
Level River St
la source