Bob l'archer

      o         
    /( )\                                         This is Bob. 
     L L                                          Bob wants to be an archer.
#############

    .
   / \          <--- bow                          So he bought himself a
  (c -)->       <--- arrow                        nice longbow and is about
  ( )/          <--- highly focused Bob           shoot at a target.
  L L           
#############

___________________________________________________________________________________________
sky

                     Bob is a smart guy. He already knows what angle and
                     velocity his arrow has / will have. But only YOU know
                     the distance to the target, so Bob doesn't know if he
                     will hit or miss. This is where you have to help him.

     .                                                                                  +-+
    / \                                                                                 | |
   (c -)->                                                                              | |
   ( )/                                                                                 +++
   L L                                                                                   |
###########################################################################################

Tâche

Votre tâche consiste à rendre une image d'art ASCII de Bob frappant ou manquant la cible. Pour le calcul:

• Votre programme recevra arrow_x,angle,velocity,distanceune entrée séparée par des virgules dans l'ordre que vous souhaitez.
• Un caractère ASCII est égal à 1m.
• Le premier caractère de la dernière ligne a les coordonnées (0,0), donc le sol (rendu comme #) est à y=0.
• Bob se tient toujours au sol, sa yposition ne change pas.
• Il n'y a pas de max y. Cependant, le sommet des flèches doit tenir dans l'image rendue.
• Toutes les entrées sont fournies sous forme d'entier décimal.
• Pendant le calcul, supposez que la flèche est un point.
• L'origine de la flèche est la tête >de flèche d'un Bob qui tire (voir ci-dessus). Donc, étant donné arrow_x, vous devez calculer arrow_y. Le pied gauche de Bob dans la sortie doit correspondre à la xcoord. du tournage de Bob.
• distanceest la xcoordonnée du pied de la cible . (c.-à-d. au milieu de la cible).
• Toutes les mesures sont fournies en mètres et degrés respectivement.
• Attention: Le tournage de Bob n'est jamais rendu, uniquement utilisé pour les calculs! Voir ci-dessous pour les deux bobines de sortie valides
• Frapper la cible signifie que le chemin des flèches traverse l'un des deux murs cibles les plus à gauche ( |) (c'est-à-dire (distance-1,3) ou (distance-1,4). Si à un moment donné la flèche se trouve dans ces 2 m², placez le X au lieu du mur qu'il frappe. La cible a toujours la même hauteur et seule sa position x peut changer.). Les coups de coin ou une flèche tombant du ciel sur la cible ne comptent pas.
• La terre standard g s'applique (9,81 m / s ^ 2).
• distance+1 est la fin du champ, après cela, tout est raté et aucune flèche ne doit être rendue.
• Si la flèche atteint la cible d'une autre manière ( distance-1etc.), aucune flèche ne doit être rendue.

Mademoiselle

Ceci est un exemple de rendu de Bob manquant (la flèche pénètre dans le sol à 34m, l'angle est à 45 °, le temps dans l'air est de 10s, la vitesse est ~ 50 - mais il y a beaucoup plus d'entrées possibles pour provoquer cette sortie. Montrez simplement que votre programme utilise le formules habituelles pour calculer des résultats physiquement "précis".):

                                                                                        +-+
                                                                                        | |
  c\                                                                                    | |
/( )                              v                                                     +++
 L L                              |                                                      |
###########################################################################################

Frappé

Ceci est un exemple de rendu du score de Bob (la flèche entre dans la cible (= croise son chemin)):

                                                                                        +-+
                                                                                     >--X |
 \c/                                                                                    | |
 ( )                                                                                    +++
 L L                                                                                     |
###########################################################################################

Exemple

• arrow_xest 7. arrow_yest toujours 3.
• angleest 30°ou 0.523598776radians.
• velocityest 13m/s.
• distance a 20 ans.

Donc, pour toucher la cible, la flèche doit traverser (19,3)ou (19,4). Tout le reste sera un échec. Dans ce cas, la flèche entrera dans le sol (les moyens yseront <1.0) 12.9358m = ~13maprès 1.149s.

Limites et notation

• Il s'agit de code-golf , donc la solution la plus courte l'emporte. Il n'y a pas de bonus.
• Votre programme (comme dans not function ) doit accepter les entrées dans le format décrit ci-dessus, aucune entrée supplémentaire n'est autorisée.
• Vous n'avez pas à gérer les entrées incorrectes / inutiles / impossibles.
• Imprimez sur ce qui est la sortie raisonnable la plus courte pour votre langue (std, fichier, ...).
• Je ne me soucie pas de laisser un espace vide.
• Astuce: La largeur de sortie est distance+2. La hauteur est apex+1.

Rubis, 482

include Math
def f s,e,l
[s,' '*(l-s.size-e.size),e].join
end
alias p puts
X,o,V,d=$*[0].split(?,).map &:to_i
o*=PI/180
L=X+d
B='| |'
S=''
G=' L L'
p f S,'+-+',L
d.times{|x|y=3+x*tan(o)-(9.81*x**2)/(2*(V*cos(o))**2)
if x==d-1&&(3..5)===y
s='>--X |'
m=(3..4)===y
p f S,m ?B: s,L
p f ' \c/',m ?s: B,L
p f ' ( )',?+*3,L
p f G,'| ',L
elsif y<=1 || x==d-1
p f S,B,L
p f '  c\\',B,L
print f '/( )', y<1? 'V':' ',x
p f S,?+*3,L-x
print f G, y<1? '|':' ',x
p f S,'| ',L-x
break
end}
p ?#*L

Non golfé

include Math
def fill s,e,l
   [s,' '*(l-s.size-e.size),e].join
end
arrow_x,angle,velocity,distance = $*[0].split(',').map(&:to_i)
angle *= PI/180
length=arrow_x+distance
loss = '| |'
puts fill '','+-+',length
distance.times { |x|
  y = 3 + x*tan(angle) - (9.81*x**2)/(2*(velocity*cos(angle))**2)
  if x == distance-1 && (3..5)===y
    puts fill '',(3..4)===y ? '| |':'>--X |',length
    puts fill ' \c/',(3..4)===y ? '>--X |':'| |',length
    puts fill ' ( )','+++',length
    puts fill ' L L','| ',length
  elsif y<=1 || x==distance-1
    puts fill '',loss,length
    puts fill '  c\\',loss,length
    print fill '/( )', y<1? 'v': ' ', x
    puts fill '','+++',length-x
    print fill ' L L', y<1? '|': ' ', x
    puts fill '',' | ',length-x
    break
  end
}
puts ?#*length

Méthode

L'équation principale ici est:

Remarque: image prise à partir de https://en.wikipedia.org/wiki/Trajectory_of_a_projectile

Où,

y0: initial height (of arrow)  
Ө: the angle  
x: the position of the arrow  
g: gravity (9.81)
v: velocity

Ce que je fais, c'est parcourir les nombres de 0 à (distance -1) et à chaque itération, vérifier si la flèche touche le sol (ou la cible)