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

Zadanie

Twoim zadaniem jest wyrenderowanie artystycznego obrazu ASCII, gdy Bob uderza lub nie trafia w cel. Do obliczeń:

• Twój program otrzyma arrow_x,angle,velocity,distancedane oddzielone przecinkami w dowolnej kolejności.
• Jeden znak ASCII jest równy 1m.
• Pierwszy znak w ostatnim wierszu ma współrzędne (0,0), więc podstawa (renderowana jako #) znajduje się na y=0.
• Bob zawsze stoi na ziemi, jego ypozycja się nie zmienia.
• Nie ma maks y. Jednak wierzchołek strzałek powinien mieścić się w renderowanym obrazie.
• Wszystkie dane wejściowe są podawane jako liczba całkowita dziesiętna.
• Podczas obliczeń załóż, że strzałka jest punktem.
• Początek strzały to strzałka >strzelającego Boba (patrz wyżej). Biorąc to pod uwagę arrow_x, musisz obliczyć arrow_y. Lewa stopa Boba na wyjściu musi być zgodna z xkoordynacją. strzelającego Boba.
• distancejest xwspółrzędną stopy celu . (tj. środek celu).
• Wszystkie pomiary są podawane odpowiednio w metrach i stopniach.
• Uwaga: Strzelający Bob nigdy nie jest renderowany, służy tylko do obliczeń! Zobacz poniżej dwa prawidłowe boby wyjściowe
• Uderzenie w cel oznacza, że ​​ścieżka strzały przecina jedną z dwóch skrajnie lewych ścian celu ( |) (To znaczy (odległość 1,3) lub (odległość 1,4). Jeśli w którymś momencie strzałka znajduje się w granicach 2 m2, umieść X zamiast ściany, w którą uderza, cel jest zawsze tej samej wysokości i tylko jego pozycja x może się zmienić.). Trafienia w narożnik lub strzała spadająca z nieba na cel nie liczą się.
• Obowiązuje standardowa masa g (9,81 m / s ^ 2).
• distance+1 jest końcem pola, potem wszystko jest chybione i żadna strzała nie powinna być renderowana.
• Jeśli strzała trafi w cel w jakikolwiek inny sposób ( distance-1itp.), Nie należy jej renderować.

Chybienie

Jest to przykład renderowania brakującego Boba (strzałka wchodzi w ziemię na 34 m, kąt wynosi 45 °, czas w powietrzu wynosi 10 s, prędkość wynosi ~ 50 - ale istnieje wiele innych możliwych danych wejściowych, które mogą spowodować takie wyjście. Po prostu pokaż, że twój program używa zwykłe wzory do obliczania wyników „dokładnych” fizycznie.):

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

Trafienie

To jest przykładowe renderowanie punktacji Boba (strzałka wchodzi w cel (= przecina jego ścieżkę)):

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

Przykład

• arrow_xwynosi 7. arrow_ywynosi zawsze 3.
• anglejest 30°lub 0.523598776radianami.
• velocityjest 13m/s.
• distance ma 20 lat

Aby trafić w cel, strzałka musi przejść (19,3)lub (19,4). Wszystko inne będzie brakowało. W takim przypadku strzałka wejdzie w ziemię (znaczy, yże będzie <1.0) 12.9358m = ~13mpóźniej 1.149s.

Limity i wyniki

• To jest golf golfowy , więc wygrywa najkrótsze rozwiązanie. Nie ma bonusów.
• Twój program (jak nie działa ) musi akceptować dane wejściowe w formacie opisanym powyżej, dodatkowe dane nie są dozwolone.
• Nie musisz obsługiwać złych / bezcelowych / niemożliwych danych wejściowych.
• Drukuj na cokolwiek, co jest najkrótszym rozsądnym wyjściem dla twojego języka (standard, plik, ...).
• Nie dbam o końcowe spacje.
• Wskazówka: szerokość wyjściowa wynosi distance+2. Wysokość to 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

Nie golfił

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

metoda

Główne równanie tutaj to:

Uwaga: zdjęcie pochodzi z https://en.wikipedia.org/wiki/Trajectory_of_a_projectile

Gdzie,

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

To, co robię, to przewijanie liczb od 0 do (odległość -1) i przy każdej iteracji sprawdzam, czy strzała uderza w ziemię (lub w cel)