बॉब द बोमन

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

कार्य

आपका काम बॉब हिटिंग या टारगेट को गायब करने का एक ASCII कला चित्र प्रस्तुत करना है। गणना के लिए:

आपका कार्यक्रम arrow_x,angle,velocity,distanceकिसी भी क्रम में अल्पविराम से अलग किए गए इनपुट के रूप में आपको मिलेगा ।
एक ASCII वर्ण बराबर होता है 1m।
अंतिम पंक्ति में पहले वर्ण में निर्देशांक हैं (0,0), इसलिए जमीन (जैसा कि प्रस्तुत है #) पर है y=0।
बॉब हमेशा जमीन पर खड़ा रहता है, उसकी yस्थिति नहीं बदलती है।
कोई अधिकतम नहीं है y। हालांकि, एरो एपेक्स को प्रदान की गई तस्वीर के भीतर फिट होना चाहिए।
सभी इनपुट को दशमलव पूर्णांक के रूप में प्रदान किया गया है।
गणना के दौरान, मान लें कि तीर एक बिंदु है।
तीर उत्पत्ति >एक शूटिंग बॉब के तीर प्रमुख है (ऊपर देखें)। इसलिए arrow_x, आपको गणना करनी होगी arrow_y। आउटपुट में बॉब के बाएं पैर को xसमन्वय से मेल खाना है । शूटिंग बॉब की।
distanceहै xलक्ष्य के समन्वय पैर । (यानी लक्ष्य के बीच में)।
सभी माप क्रमशः मीटर और डिग्री में प्रदान किए जाते हैं।
ध्यान दें: शूटिंग बॉब को कभी भी प्रस्तुत नहीं किया जाता है, केवल गणना के लिए उपयोग किया जाता है! नीचे दो वैध आउटपुट-बोब्स के लिए देखें
लक्ष्य से टकराने का अर्थ है कि तीर का रास्ता या तो दो सबसे बाईं ओर की दीवारों में से एक को पार करता है ( |) (जो कि या तो (दूरी-1,3) या (दूरी-1,4) है। यदि किसी बिंदु पर तीर उन 2 वर्ग मीटर के भीतर है, तो दीवार के बजाय एक्स हिट करता है। लक्ष्य हमेशा एक ही ऊंचाई है और केवल इसकी एक्स स्थिति बदल सकती है।)। कॉर्नर हिट या लक्ष्य पर आकाश से गिरने वाला तीर गिनती नहीं करता है।
मानक पृथ्वी जी लागू होता है (9.81 मीटर / सेकेंड 2)।
distance+1 क्षेत्र का अंत है, उसके बाद, सब कुछ एक मिस है और किसी भी तीर का प्रतिपादन नहीं किया जाना चाहिए।
यदि तीर किसी अन्य तरीके से लक्ष्य को हिट करता है ( distance-1आदि), तो किसी भी तीर को रेंडर नहीं किया जाना चाहिए।

कुमारी

यह बॉब लापता का एक उदाहरण प्रतिपादन है (तीर 34 मीटर पर जमीन में प्रवेश करता है, कोण 45 ° है, हवा में समय 10 एस है, वेग ~ 50 है - लेकिन इस आउटपुट को उत्पन्न करने के लिए बहुत अधिक संभावित इनपुट हैं। बस अपने कार्यक्रम का उपयोग करता है। सामान्य रूप से "सटीक" परिणामों की गणना करने के सूत्र।):

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

मारो

यह बॉब स्कोरिंग का एक उदाहरण प्रदान करता है (तीर लक्ष्य में प्रवेश करता है (= अपने पथ को पार करता है)):

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

उदाहरण

arrow_xहै 7. arrow_yहमेशा 3 है।
angleहै 30°या 0.523598776रेडियंस।
velocityहै 13m/s।
distance 20 है।

तो लक्ष्य को हिट करने के लिए, तीर को पार करना होगा (19,3)या (19,4)। बाकी सब कुछ मिस होगा। इस मामले में, तीर जमीन (साधन में प्रवेश करेंगे yहो जाएगा <1.0पर) 12.9358m = ~13mके बाद 1.149s।

सीमा और स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा समाधान जीतता है। कोई बोनस नहीं है।
आपके कार्यक्रम (जैसा कि फ़ंक्शन में नहीं ) को ऊपर वर्णित प्रारूप में इनपुट को स्वीकार करना होगा, अतिरिक्त इनपुट की अनुमति नहीं है।
आपको गलत / निरर्थक / असंभव जानकारी नहीं देनी होगी।
जो कुछ भी आपकी भाषा के लिए सबसे कम उचित आउटपुट है उसे प्रिंट करें (std, file, ...)।
मैं व्हाट्सएप को पीछे करने की परवाह नहीं करता।
टिप: आउटपुट की चौड़ाई है distance+2। ऊंचाई है apex+1।

code-golf ascii-art physics

— mınxomaτ
स्रोत

क्या आप कृपया दिए गए आउटपुट को उत्पन्न करने के लिए उपयोग किए गए इनपुट को जोड़ सकते हैं?

— ब्लू

आप एक समारोह क्यों नहीं कर सकते?

— लवजो सेप

@Mdd आपको उसे ड्रा करना है, जैसा कि टास्क में बताया गया है। The left foot of Bob in the output has to match the x coord. of the shooting Bob.औरSee below for the two valid output-Bobs

— mınxomaτ

और हममें से जिन्होंने जीसीएसई की तुलना में भौतिकी को आगे नहीं बढ़ाया है (या अभी भूल गए हैं?)

— ब्लू

@muddyfish प्रक्षेपवक्र समीकरणों के लिए बस Google।

— mınxomaτ

रूबी, 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

तरीका

यहाँ मुख्य समीकरण है:

नोट: छवि https://en.wikipedia.org/wiki/Trajectory_of_a_projectile से ली गई है

कहाँ पे,

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

मैं जो कर रहा हूं उसे 0 से (दूरी -1) तक की संख्याओं के माध्यम से लूप करना है और प्रत्येक पुनरावृत्ति जांच में यह देखने के लिए कि क्या तीर जमीन से टकराता है (या लक्ष्य)

— mhmd
स्रोत

बॉब द बोमन!