Bob, o arqueiro

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

Tarefa

Sua tarefa é renderizar uma imagem artística de ASCII de Bob atingindo ou errando o alvo. Para o cálculo:

• Seu programa receberá arrow_x,angle,velocity,distancecomo entrada separada por vírgula, em qualquer ordem que desejar.
• Um caractere ASCII é igual 1m.
• O primeiro caractere na última linha possui as coordenadas (0,0), portanto o chão (renderizado como #) está em y=0.
• Bob sempre fica no chão, sua yposição não muda.
• Não há max y. No entanto, o ápice das setas deve caber na imagem renderizada.
• Toda entrada é fornecida como número inteiro decimal.
• Durante o cálculo, assuma que a seta é um ponto.
• A origem da flecha é a ponta da flecha >de um Bob em tiro (veja acima). Então arrow_x, dado , você tem que calcular arrow_y. O pé esquerdo de Bob na saída deve corresponder à xcoord. do tiroteio Bob.
• distanceé a xcoordenada do pé do alvo . (ou seja, o meio do alvo).
• Todas as medições são fornecidas em metros e graus, respectivamente.
• Atenção: O tiro Bob nunca é renderizado, apenas usado para cálculos! Veja abaixo os dois Bobs de saída válidos
• Atingir o alvo significa que o caminho das flechas cruza uma das duas paredes mais à esquerda ( |) (ou seja, (distância 1,3) ou (distância 1,4)). Se em algum momento a seta estiver dentro desses 2m², o X em vez da parede que atinge. O alvo sempre tem a mesma altura e apenas sua posição x pode mudar.). Os acertos de canto ou uma flecha caindo do céu para o alvo não contam.
• O terra padrão g é aplicado (9,81 m / s ^ 2).
• distance+1 é o fim do campo; depois disso, tudo está errado e nenhuma flecha deve ser renderizada.
• Se a flecha acertar o alvo de qualquer outra maneira ( distance-1etc.), nenhuma flecha deve ser renderizada.

Senhorita

Este é um exemplo de como Bob está ausente (a seta entra no solo a 34m, o ângulo é 45 °, o tempo no ar é 10s, a velocidade é ~ 50 - mas existem muito mais entradas possíveis para causar essa saída. Apenas mostre que seu programa usa o fórmulas usuais para calcular resultados fisicamente "precisos".):

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

Bater

Este é um exemplo de renderização da pontuação de Bob (a seta entra no alvo (= cruza seu caminho)):

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

Exemplo

• arrow_xé 7. arrow_yé sempre 3.
• angleé 30°ou 0.523598776radianos.
• velocityé 13m/s.
• distance é 20.

Então, para atingir o alvo, a flecha precisa cruzar (19,3)ou (19,4). Tudo o resto será uma falta. Nesse caso, a flecha entrará no chão (as médias yserão <1.0) 12.9358m = ~13mdepois 1.149s.

Limites e pontuação

• Isso é código-golfe , então a solução mais curta vence. Não há bônus.
• O seu programa (como na função não ) deve aceitar entradas no formato descrito acima; entradas adicionais não são permitidas.
• Você não precisa lidar com entradas erradas / inúteis / impossíveis.
• Imprima na saída razoável mais curta para o seu idioma (std, arquivo, ...).
• Eu não ligo para rastrear espaços em branco.
• Dica: a largura da saída é distance+2. A altura é apex+1.

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

Método

A equação principal aqui é:

Nota: imagem obtida em https://en.wikipedia.org/wiki/Trajectory_of_a_projectile

Onde,

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

O que estou fazendo é percorrer números de 0 a (distância -1) e em todas as iterações, verifique se a flecha atinge o chão (ou o alvo)