मेरी मदद करो मैं समुद्र में खो गया हूँ!

Question

परिचय

आज मैं अपने डोंगी के साथ अकेले मछली पकड़ने गया, दुर्भाग्य से मैं सो गया और धारा ने मुझे दूर कर दिया, मैंने अपने ओअर खो दिए, अब रात हो गई है और मैं समुद्र में खो गया हूं! मैं तट नहीं देख सकता इसलिए मुझे बहुत दूर जाना चाहिए!

मेरे पास अपना सेल फोन है लेकिन यह खराबी है क्योंकि यह नमकीन पानी से गीला हो गया है, मैं कुछ भी नहीं बोल सकता या सुन नहीं सकता क्योंकि माइक और फोन स्पीकर टूट गए हैं, लेकिन मैं अपने दोस्त को एसएमएस भेज सकता हूं जो समुद्र तट पर है!

मेरे दोस्त के पास एक बहुत शक्तिशाली मशाल है और उसने मुझे सही दिशा दिखाने के लिए बांस के डिब्बे के ऊपर उठाया, लेकिन मैं रो नहीं सकता क्योंकि मेरे पास कोई ओअर नहीं है, इसलिए मुझे उसे बताना होगा कि मैं कितनी दूर हूं ताकि वह किसी को भेज सके पकढो मुझे!

मेरे दोस्त ने मुझे बताया कि वह समुद्र तल से 11.50 मीटर की दूरी पर मशाल रख रहा है, और मैं क्षितिज पर प्रकाश को देख सकता हूं। अब मुझे केवल स्कूल से याद आया कि पृथ्वी का दायरा समुद्र तल से 6371 किलोमीटर होना चाहिए, और मैं अपने डोंगी में बैठ रहा हूँ ताकि आप यह मान सकें कि मेरी आँखें समुद्र तल पर भी हैं।

कार्य

चूंकि धाराएँ मुझे पल-पल आगे बढ़ा रही हैं, मेरा दोस्त समय-समय पर मशाल उठा रहा है (अब 12.30 मीटर की दूरी पर है), कृपया एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें जो मुझे मेरे दोस्त की स्थिति से दूरी की गणना करने में मदद करेगा!

यहाँ एक आरेख है (पैमाने पर नहीं):

जो नारंगी बिंदु लेबल किया गया Mहै, वह है, लाल बिंदु लेबल Tवाला टॉर्च है। हरी रेखा Mऔर के बीच की रैखिक दूरी हैT

इनपुट

मानक इनपुट से मशाल की ऊँचाई hको समुद्र तल पर मीटरों में लें, जिसे मैं क्षितिज के ठीक ऊपर देखता हूँ, दो दशमलव दशमलव सटीकता (1 सेंटीमीटर या 0.01 मीटर की सटीकता के साथ) के साथ एक फ्लोटिंग पॉइंट नंबर के रूप में। जिसमें 0 से लेकर 100 तक शामिल हैं।

उत्पादन

आपको 1 सेमी की सटीकता के साथ ग्रीन लाइन की यूक्लिडियन लंबाई वापस करनी चाहिए। उदाहरण के लिए यदि आप मीटर में आउटपुट करते हैं, तो दो डेसीमल (कम से कम) के साथ होना चाहिए। आउटपुट या तो मीटर या किलोमीटर हो सकता है, लेकिन सटीकता का सम्मान करता है।

परीक्षण के मामलों:

मीटर में सभी मान।

11.5 > 12105.08
13.8 > 13260.45

नियम

सबसे छोटा कोड जीतता है।

Comments

क्या परिणाम गणितीय रूप से सही होना चाहिए या यदि पहले 2 दशमलव ठीक हैं तो क्या यह ठीक है? मेरा मतलब है कि 2xRxh की तुलना में hxh छोटा है और छोटी दूरी के लिए उपेक्षित किया जा सकता है। (आर पृथ्वी की त्रिज्या है और एच मशाल की ऊंचाई है)।

— Osable

@ यदि आप मीटर में आउटपुट करते हैं तो पहले 2 दशमलव ठीक हैं

— मारियो

इनपुट की सीमा क्या है?

— Osable

@ आप इस इनपुट पर विचार कर सकते हैं 0 से 100 तक (यहां तक ​​कि इस मामले में आवश्यक / संभव से बहुत अधिक)।

— मारियो

आपको कोस्ट गार्ड स्टैक एक्सचेंज की कोशिश करनी चाहिए - कोड गोल्फ आपको समुद्र से बाहर निकलने में मदद नहीं कर सकता है, यार!

— corsiKa

Answer 1

05AB1E ,13 12 10 बाइट्स

Emigna के लिए धन्यवाद 2 बाइट्स सहेजे गए।

चूंकि ओपी की धारणा का उपयोग करके बुलाया जाने वाला कोई त्रिकोणमितीय फ़ंक्शन नहीं है कि पृथ्वी स्थानीय रूप से एक विमान है, इसलिए 05AB1E समाधान करना संभव हो जाता है।

•1#oC•+¹*t

           For understanding purposes input is referred to as 'h'
•1#oC•     Push 12742000 [ = 2*R, where R is the radius of earth]
      +    Compute 2*R+h
       ¹*  Multiply by h. Result is (2*R*+h)*h
         t Take the square root of it and implicitly display it

इसे ऑनलाइन आज़माएं!

Comments

12742000के रूप में लिखा जा सकता है•1#oC•

— Emigna

: संदर्भ के लिए, यह 9 बाइट्स हो गया होता •1#oC•+*tमें 2sable

— Emigna

क्या एक स्ट्रिंग •चित्रण के साथ घिरा हुआ है ... आधार 214 नंबर? 05AB1E कभी-कभी ऐसे विशेष कार्यों पर प्रलेखन की कमी से ग्रस्त है। अच्छा 2 जवाब देने योग्य भी। मुझे कुछ दिनों पहले इसके बारे में पता चला लेकिन मैंने इस प्रश्न के लिए इसका उपयोग करने के बारे में नहीं सोचा।

— Osable

सही बात। यह बेस 10 नंबर है जो 214 बेस में एनकोडेड है।

— एमिग्ना

परिणाम त्रिकोणमिति द्वारा भी प्राप्त किया जा सकता है, लेकिन संभवतः अधिक लंबा है।

— मारियो

Answer 2

पायथन, 34 26 बाइट्स:

( -8 बाइट्स ओसेबल के लिए धन्यवाद! )

lambda i:(i*(i+12742))**.5

एक अनाम मेमने का कार्य। किलोमीटर में इनपुट लेता है और किलोमीटर में आउटपुट। के रूप में आह्वान किया print(<Function Name>(<Input>))।

Comments

lambda i:(i*(i+12742))**.5और भी छोटा होगा।

— ओसेबल

@ अच्छा लगा! मैं बस यही करने वाला था। :)

— आर। कप

यदि गणितीय सहिष्णुता है, iऔर 12742 के बीच विसंगति को देखते हुए , अभिव्यक्ति को छोटा किया जा सकता है:(i*12742)**.5

— Osable

परिणाम गलत हैं। 11.5 मी -> ~ 12 किमी के बजाय ~ 380 किमी

— जीबी

@ जीबी कार्यक्रम किलोमीटर के रूप में इसके इनपुट को पढ़ता है।

— Osable

Answer 3

PHP, 34 बाइट्स

<?=sqrt((12742e3+$h=$argv[1])*$h);

टूट - फूट

   r^2+x^2=(r+h)^2      # Pythagoras base
   r^2+x^2=r^2+2rh+h^2  # right term distributed
       x^2=    2rh+h^2  # -r^2
       x =sqrt(2rh+h^2) # sqrt

अब तक, यह पुराने गणित के उत्तर के समान है

sqrt(2*6371e3*$h+$h*$h) # to PHP
sqrt(14742e3*$h+$h+$h)  # constants combined
sqrt((14742e3+$h)*$h)   # conjugation to save a byte
((14742e3+$h)*$h)**.5   # same size

अब वह सब करना बाकी है जो इनपुट =$argv[1]और आउटपुट को जोड़ना है <?=- किया गया

Answer 4

डीसी, 16 11 बाइट्स:

?d12742+*vp

किलोमीटर में कमांड लाइन के माध्यम से इनपुट के लिए संकेत और फिर किलोमीटर में दूरी आउटपुट।

व्याख्या

?           # Prompt for input
 d          # Duplicate the top-of-stack value
  12742     # Push 12,742 onto the stack
       +    # Pop the top 2 values of the stack and push their sum
        *   # Pop top 2 values of the stack and push their product
         v  # Pop the remaining value and push the square root
          p # Output the result to STDOUT

यह निम्नलिखित का लाभ लेता है:

((6371+h)**2-6371**2)**.5 
=> ((6371**2+12742h+h**2)-6371**2)**0.5 
=> (h**2+12742h)**0.5 
=> (h*(h+12742))**0.5

Answer 5

jq, 18 अक्षर

(12742e3+.)*.|sqrt

फिर भी उसी फॉर्मूले की एक और कॉपी।

नमूना रन:

bash-4.3$ jq '(12742e3+.)*.|sqrt' <<< 11.5
12105.087040166212

ऑन लाइन टेस्ट

Answer 6

हास्केल, 22 बाइट्स

d h=sqrt$h*(h+12742e3)

उपयोग:

Prelude> d 11.5
12105.087040166212

---

पॉइंटफ्री: (23 बाइट्स)

sqrt.((*)=<<(+12742e3))

Answer 7

आर, 29 बाइट्स

h=scan();sqrt(h^2+2*h*6371e3)

स्टड से इनपुट लेता है

Comments

बाइट्स की एक जोड़ी छोटी है (h=scan())*(1+12742e3/h)^.5।

— फ्लॉडरर

Answer 8

गणितज्ञ, 16 बाइट्स

किलोमीटर में इनपुट और आउटपुट दोनों के लिए इनमें से कोई भी काम करता है:

(12742#+#*#)^.5&

((12742+#)#)^.5&

यह समस्या के लिए पाइथागोरस का एक सरल अनुप्रयोग है:

   x*x + R*R = (R+h)*(R+h)
=> x*x = (R+h)*(R+h) - R*R
       = R*R + 2*R*h + h*h - R*R
       = 2*R*h + h*h
=>   x = √(2*R*h + h*h)

Answer 9

जेली, जेली के कोड पृष्ठ में 9 बाइट्स

मैंने एक गोल्फिंग भाषा में कार्यक्रम लिखने का फैसला किया। मुझे वास्तव में एक और अधिक कुशल एल्गोरिथ्म मिला, जिसका उपयोग अन्य लोग कर रहे हैं (कम से कम दूरी पर प्रश्न में एक की तरह), लेकिन इसके लिए शाब्दिक फ़्लोटिंग-पॉइंट नंबरों की आवश्यकता होती है जो जेली को संपीड़ित करने में सक्षम नहीं लगती है, इसलिए पाइथागोरस यह है।

+“Ȯịż’×µ½

स्पष्टीकरण:

 “Ȯịż’     12742000, compressed base-250
+          add to argument
      ×    multiply with original argument
       µ   separator to avoid what would otherwise be a parsing ambiguity
        ½  square root everything seen so far
           implicit output at EOF

µविभाजक की आवश्यकता मुझे परेशान करती है, लेकिन मुझे लगता है कि यह अपरिहार्य है; जेली ने पहले से ही 05AB1E पर एक बाइट को बचा लिया है, जो यह अनुमान लगाने में सक्षम है कि कमांडों में से कितने की जरूरत है, लेकिन इस मामले में यह अंत तक सही ढंग से अनुमान नहीं लगा सकता है, इसलिए मुझे इसे संकेत देने की आवश्यकता है।

जेली, जेली के कोड पृष्ठ में 7 बाइट्स

דȮịż’½

जैसा कि मैंने अपने अन्य उत्तर में समझाया , पाइथागोरस सन्निकटन के लिए श्रृंखला सन्निकटन वास्तव में प्रश्न में शामिल लंबाई पर बेहतर परिणाम पैदा करता है (कम से कम, वे उदाहरण आउटपुट के करीब हैं), और इसका एक छोटा सूत्र भी है। जब मैं इसे लिख रहा था, मुझे एहसास हुआ कि पहले से 12742000 के वर्गमूल की गणना करने के बजाय, मैं पहले संख्या को 12742000 से गुणा कर सकता हूं, और फिर एक ही समय में दोनों को वर्गमूल कर सकता हूं। यह मूल रूप से जोड़ के बिना अन्य सूत्र के बराबर है, और इस तरह, यह पिछले कार्यक्रम से इसके अतिरिक्त को हटाने के माध्यम से उत्पादित किया जा सकता है। यह दो बाइट्स को बचाता है, क्योंकि अब यह स्पष्ट रूप से पार्स करता है और इसलिए हमें µकिसी भी अधिक की आवश्यकता नहीं है ।

Comments

मैंने इस अनुकूलन का उपयोग नहीं करने का फैसला किया क्योंकि यह उसी मानों को उत्पन्न नहीं करता है यदि आप सेंटीमीटर (cf. अनुरोधित आउटपुट) को देखते हैं, जिसे h की श्रेणी दी गई है। यह 05AB1E में 2 बाइट्स भी बचाएगा।

— Osable

अनुकूलन के साथ, मुझे 12105.081577585506 और 13260.452480967608 के आउटपुट मिलते हैं; वे परीक्षण मामले के आउटपुट के बहुत करीब हैं, और उनके लिए गोल है। इसके बिना, मुझे 12105.087040166212 और 13260.459661716106 मिलते हैं, जो आगे दूर हैं (और उत्तरार्ध सेंटीमीटर में गलत है, 13260.46 तक।) जैसा कि अन्य उत्तर में उल्लेख किया गया है, ऑप्टिमाइज़ेशन अनुकूलित कोड की तुलना में सही मूल्य के करीब होता है क्योंकि इसमें दो त्रुटियां होती हैं जो मोटे तौर पर एक दूसरे को रद्द कर देती हैं, बजाय केवल एक को रद्द करने के जिसके पास कुछ भी नहीं है।

चूँकि आपने समीक्षा कतार में "खुला छोड़ना" को वोट दिया था, इसलिए मुझे लगता है कि आप मानते हैं कि आप उन सवालों के जवाब जानते हैं जिनके लिए मैंने टिप्पणियों में स्पष्टीकरण का अनुरोध किया था। इसलिए कृपया प्रश्न को संपादित करें ताकि यह अस्पष्ट हो।

— पीटर टेलर

सवाल स्पष्ट नहीं है: लेखक को नेविगेट करने में मदद करने के लिए अपने दोस्त से दूरी जानने की जरूरत है। वह मशाल की स्थिति को 0.1 मीटर की सटीकता से निर्धारित कर सकता है (हम इसे उस कहानी से निर्धारित कर सकते हैं जो बताई गई है)। यह अनिवार्य रूप से वर्तमान दूरी पर आउटपुट से लगभग 1 मीटर अनिश्चितता देने वाला है (ध्यान दें: लेखक चारों ओर बह रहा है, इस प्रकार बहुत तेज़ी से आगे बढ़ने की संभावना नहीं है ...), और इसलिए कुछ भी जो सटीक होने की संभावना है स्वीकार्य। समस्या का हिस्सा यह निर्धारित कर रहा है कि इस स्थिति में आपको कितना सटीक होना चाहिए!

आवश्यक आउटपुट मीटर में 2 दशमलव दिखाता है। इसलिए सटीकता 1 सेंटीमीटर होने की उम्मीद है। प्रश्न के लिए टिप्पणियों में, ओपी ने कहा कि एच 100 तक जा सकता है। एच = 100 के साथ मूल एल्गोरिथ्म से 14 सेंटीमीटर की विसंगति है।

— Osable

Answer 10

रूबी, २३

23 बाइट, किमी में

->h{(h*h+h*12742)**0.5}

25 बाइट्स, मी में

->h{(h*h+h*12742e3)**0.5}

Answer 11

Tcl, 49 बाइट्स:

set A [get stdin];puts [expr ($A*($A+12742))**.5]

खैर, मैं Tcl में बिल्कुल नया हूं, इसलिए इसे नीचे गिराने के किसी भी सुझाव की बहुत सराहना की जाती है। मेरे अन्य उत्तरों की तरह, किलोमीटर में कमांड लाइन इनपुट और किलोमीटर में आउटपुट के लिए संकेत देता है। अनिवार्य रूप से मेरे मौजूदा dcऔर pythonउत्तरों का एक टीईसी अनुकूलन ।

Comments

वहाँ एक रों पर मिलता लापता रों

— sergiol

Answer 12

x86_64 + SSE मशीन कोड, 16 बाइट्स

कार्यक्रम के बाइट्स बाईं ओर हैं (हेक्साडेसिमल में), इसे पढ़ने के लिए थोड़ा आसान बनाने के लिए दाईं ओर एक disassembly है। यह एक ऐसा फ़ंक्शन है जो एकल-सटीक फ़्लोटिंग पॉइंट संख्या लेने और वापस करने के कार्यों के लिए सामान्य x86_64 सम्मेलन का अनुसरण करता है (यह% xmm0 में तर्क लेता है और उसी रजिस्टर में अपना उत्तर देता है, और अस्थायी रूप से% xmm1 और% ex का उपयोग करता है; समान कॉलिंग कन्वेंशन हैं जिन्हें C प्रोग्राम उपयोग करेगा, और जैसे आप फ़ंक्शन को C प्रोग्राम से सीधे कॉल कर सकते हैं, जो कि मैंने इसे कैसे परीक्षण किया है)।

b8 80 19 5f 45          mov    $0x455f1980,%eax
66 0f 6e c8             movd   %eax,%xmm1
0f 51 c0                sqrtps %xmm0,%xmm0
0f 59 c1                mulps  %xmm1,%xmm0
c3                      retq

हालांकि, यह अभी भी एक स्पष्टीकरण की जरूरत है। सबसे पहले, यह सूत्र पर चर्चा करने लायक है। अधिकांश लोग पृथ्वी की वक्रता की अनदेखी कर रहे हैं और दूरी को मापने के लिए पाइथागोरस के सूत्र का उपयोग कर रहे हैं। मैं भी कर रहा हूँ, लेकिन मैं एक श्रृंखला विस्तार सन्निकटन का उपयोग कर रहा हूँ; मैं केवल इनपुट की पहली शक्ति से संबंधित शब्द ले रहा हूं, और तीसरी, पांचवीं, सातवीं, आदि शक्तियों की अनदेखी कर रहा हूं, जिनका इस छोटी दूरी पर केवल बहुत कम प्रभाव है। (इसके अलावा, पाइथागोरस सन्निकटन एक कम मूल्य देता है, जबकि श्रृंखला विस्तार में बाद के शब्द मूल्य को कम करने के लिए कार्य करते हैं; इस तरह, एक मामूली कारक की अनदेखी करके जो कि सन्निकटन को गलत दिशा में धकेलने के लिए काम करेगा, मैं वास्तव में प्राप्त करने के लिए होता हूं) कम सटीक सूत्र का उपयोग करके अधिक सटीक परिणाम।) सूत्र 4212742000 × √h निकला;0x455f1980।

अगली चीज जो लोगों को भ्रमित कर सकती है, वह यह है कि मैं वर्गमूल और बहुगुणित के लिए वेक्टर निर्देशों का उपयोग क्यों कर रहा हूं; %xmm0और %xmm1प्रत्येक में चार एकल-सटीक फ़्लोटिंग पॉइंट संख्या रख सकते हैं, और मैं सभी चार पर काम कर रहा हूँ। यहाँ तर्क वास्तव में सरल है: उनके एन्कोडिंग इसी स्केलर निर्देशों की तुलना में एक बाइट कम है। तो मैं FPU कर सकता हूँ एक अतिरिक्त कार्य वर्ग-रूटिंग और जीरो को गुणा करने के लिए अपने आप को दो बाइट्स बचाने के लिए, एक विधि में जो विशिष्ट गोल्फिंग भाषा एल्गोरिथ्म का बहुत ही अनुशीलन है। (मैंने x86 असेंबलर को थोड़ी देर पहले चैट में असेंबलरों की गोल्फ भाषा कहा था, और मैंने अभी भी उस पर अपना विचार नहीं बदला है।)

वहां से, एल्गोरिथ्म बहुत सरल है: %xmm1,12742000 के माध्यम से लोड करें %eax(जो कि मेमोरी से लोड होने की तुलना में बाइट्स के मामले में कम है), वर्ग-रूट तर्क (और तीन शून्य), के समान तत्वों को गुणा करें %xmm1और %xmm0(हम केवल देखभाल करते हैं) पहले तत्व के बारे में), फिर वापस लौटें।

Answer 13

मिंकोलंग v0.15, 22 बाइट्स

ndd*$r'12742000'*+1MN.

इसे ऑनलाइन आज़माएं!

n                               gets input in the form of a number
 dd                             duplicates it twice
   *                            multiplies 2 of the duplicates with each other
                                STACK: [h, h*h]
    $r                          swap top two stack values
                                STACK: [h*h, h]
      '12742000'*               push this number and multiply the original input by it
                                STACK: [h*h, h*12742000]
                 +1M            adds the two values and takes their square root
                                STACK: [sqrt(h*h+h*12742000)]
                    N.          output as a number and end program

Answer 14

जावास्क्रिप्ट (ईएस 6), 31 25 बाइट्स

मीटर में मूल्य प्रदर्शित करता है

//the actual code 
f=h=>(h*h+12742e3*h)**0.5


console.log(f(11.5));
console.log(f(13.8));