Bob the Bowman

      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                                                                                   |
###########################################################################################

Compito

Il tuo compito è rendere un'immagine ASCII di Bob che colpisce o manca il bersaglio. Per il calcolo:

Il programma riceverà arrow_x,angle,velocity,distancecome input separato da virgole nell'ordine desiderato.
Un carattere ASCII è uguale 1m.
Il primo carattere nell'ultima riga ha le coordinate (0,0), quindi il terreno (reso come #) è a y=0.
Bob è sempre a terra, la sua yposizione non cambia.
Non c'è max y. Tuttavia, l'apice delle frecce dovrebbe adattarsi all'immagine renderizzata.
Tutto l'input è fornito come intero decimale.
Durante il calcolo, supponiamo che la freccia sia un punto.
L'origine della freccia è la punta della freccia >di un tiro a segno (vedi sopra). Quindi dato arrow_x, devi calcolare arrow_y. Il piede sinistro di Bob nell'output deve corrispondere al xcoord. delle riprese di Bob.
distanceè la xcoordinata del piede del bersaglio . (cioè il centro del bersaglio).
Tutte le misure sono fornite rispettivamente in metri e gradi.
Attenzione: il tiro di Bob non viene mai eseguito, utilizzato solo per i calcoli! Vedi sotto per i due Bob di output validi
Colpire il bersaglio significa che il percorso delle frecce attraversa una delle due pareti del bersaglio più a sinistra ( |) (ovvero (distanza-1,3) o (distanza-1,4). Se ad un certo punto la freccia si trova all'interno di quei 2m², posizionare la X invece del muro che colpisce. Il bersaglio ha sempre la stessa altezza e solo la sua posizione x può cambiare.). I colpi d'angolo o una freccia che cade dal cielo sul bersaglio non contano.
Si applica la terra standard g (9,81 m / s ^ 2).
distance+1 è la fine del campo, dopodiché tutto è un errore e nessuna freccia deve essere resa.
Se la freccia colpisce il bersaglio in qualsiasi altro modo ( distance-1ecc.), Nessuna freccia dovrebbe essere resa.

Perdere

Questo è un esempio di rendering di Bob mancante (la freccia entra nel terreno a 34m, l'angolo è 45 °, il tempo in aria è 10s, la velocità è ~ 50 - ma ci sono molti più input possibili per causare questo output. Mostra solo che il tuo programma utilizza il formule abituali per calcolare risultati fisicamente "accurati".):

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

Colpire

Questo è un esempio di rendering del punteggio di Bob (la freccia entra nel bersaglio (= incrocia il suo percorso)):

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

Esempio

arrow_xè 7. arrow_yè sempre 3.
angleè 30°o 0.523598776radianti.
velocitylo è 13m/s.
distance ha 20 anni.

Quindi, per colpire il bersaglio, la freccia deve attraversare (19,3)o (19,4). Tutto il resto ci mancherà. In questo caso, la freccia entrerà nel terreno (significa yche sarà <1.0) in 12.9358m = ~13mseguito 1.149s.

Limiti e punteggio

Questo è code-golf , quindi vince la soluzione più breve. Non ci sono bonus.
Il tuo programma (in quanto non funzionante ) deve accettare l'input nel formato sopra descritto, l'input aggiuntivo non è consentito.
Non è necessario gestire input errati / inutili / impossibili.
Stampa su qualunque sia l'output ragionevole più breve per la tua lingua (std, file, ...).
Non mi interessa trascinare gli spazi bianchi.
Suggerimento: la larghezza dell'output è distance+2. L'altezza è apex+1.

code-golf ascii-art physics

— mınxomaτ
fonte

Potete aggiungere l'input utilizzato per generare l'output fornito, per favore?

— Blu

Perché non puoi pubblicare una funzione?

— Loovjo,

@Mhmd Devi disegnarlo, come indicato nel compito. The left foot of Bob in the output has to match the x coord. of the shooting Bob.eSee below for the two valid output-Bobs

— mınxomaτ il

E per quelli di noi che non hanno preso la fisica oltre GCSE (o se ne sono appena dimenticati?)

— Blue

@muddyfish Basta google per le equazioni della traiettoria.

— mınxomaτ,

Ruby, 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

Ungolfed

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

Metodo

L'equazione principale qui è:

Nota: immagine tratta da https://en.wikipedia.org/wiki/Trajectory_of_a_projectile

Dove,

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

Quello che sto facendo è fare un ciclo tra i numeri da 0 a (distanza -1) e in ogni iterazione controlla se la freccia colpisce il suolo (o il bersaglio)

— MHMD
fonte

Bob the Bowman!