एक त्रिकोण का गोलाकार अतिरिक्त

Question

एक त्रिकोण का गोलाकार अतिरिक्त

जैसा कि हम सभी जानते हैं कि किसी भी ग्रह के त्रिभुज के कोणों का योग 180 डिग्री के बराबर होता है।

हालांकि, एक गोलाकार त्रिकोण के लिए, कोणों का योग हमेशा 180 डिग्री से अधिक होता है। गोलाकार त्रिभुज कोण और 180 डिग्री के योग के बीच के अंतर को गोलाकार अतिरिक्त कहा जाता है । कार्य दिए गए शीर्ष निर्देशांक के साथ एक त्रिकोण के गोलाकार अतिरिक्त की गणना करना है।

कुछ पृष्ठभूमि

एक गोलाकार त्रिभुज गोले के तीन महान वृत्तों द्वारा परिभाषित क्षेत्र का एक हिस्सा है।

गोलाकार त्रिभुज के दोनों किनारों और कोणों को कोण माप के शब्द में मापा जाता है, क्योंकि प्रत्येक पक्ष को गोले के एक चौराहे के रूप में माना जा सकता है और गोले के केंद्र में शीर्ष के साथ कुछ प्लानेर कोण हैं:

प्रत्येक तीन अलग-अलग महान वृत्त 8 त्रिकोणों को परिभाषित करते हैं, लेकिन हम केवल उचित त्रिकोणों को ही ध्यान में रखते हैं, अर्थात। त्रिकोण जिनके कोण और पक्ष उपाय संतुष्ट करते हैं

भौगोलिक समन्वय प्रणाली के संदर्भ में एक त्रिकोण के कोने को परिभाषित करना सुविधाजनक है। क्षेत्र के एक चाप की लंबाई की गणना करने के लिए देशांतर λ और उसके छोरों के अक्षांश को देखते हुए हम सूत्र का उपयोग कर सकते हैं:

, कहाँ पे

या अधिक स्पष्ट रूप से:

(स्रोत: https://en.wikipedia.org/wiki/Haversine_formula )

गोलाकार त्रिभुज को हल करने के लिए उपयोग किए जा सकने वाले दो मूल सूत्र हैं:

• कॉशन का नियम:

• साइन का नियम:

(स्रोत: https://en.wikipedia.org/wiki/Spherical_trigonometry#Cosine_rules_and_sine_rules )

तीन पक्षों को देखते हुए, कोसाइन नियम का उपयोग करके कोणों की गणना करना आसान है:

अंत में, एक त्रिकोण की गोलाकार अधिकता को परिभाषित किया गया है:

एक त्रिकोण और उसके क्षेत्र के गोलाकार अतिरिक्त के बीच के संबंध के बारे में क्या दिलचस्प है:

तो एक इकाई क्षेत्र पर, एक त्रिभुज की अधिकता उस त्रिभुज के क्षेत्रफल के बराबर होती है!

काम

एक फंक्शन या एक प्रोग्राम लिखें जो त्रिभुज वर्टिकल कोऑर्डिनेट्स को देखते हुए डिग्रियों में एक त्रिकोण के गोलाकार अतिरिक्त की गणना करेगा। भौगोलिक निर्देशांक प्रणाली के संदर्भ में शीर्ष निर्देशांक प्रदान किए जाते हैं।

प्रत्येक शीर्ष को फार्म में पारित किया जाना चाहिए [latitude in degrees][N|S][longitude in degrees][E|W]। जब अक्षांश 90 के हो तो देशांतर और E/ Wको छोड़ दिया जा सकता है । 90N, 90S, 10N100E, 30S20Wउचित शिखर वर्णन, जबकि कर रहे हैं 80Nया 55Sनहीं कर रहे हैं।

परीक्षण के मामलों में अक्षांश और देशांतर हमेशा पूर्णांक होते हैं।

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

उदाहरण

इनपुट

90N0E
0N0E
0N90E

उत्पादन

89.999989

इनपुट

90N
0N0E
0N90E

उत्पादन

89.999989

इनपुट

0N0E
0N179E
90N0E

उत्पादन

178.998863

इनपुट

10N10E
70N20W  
70N40E

उत्पादन

11.969793

सभी परीक्षण मामलों में देशांतर और अक्षांश पूर्णांक संख्या होते हैं। शिखर निर्देशांक पार्स, काम का हिस्सा है इसलिए एक शीर्ष एकल स्ट्रिंग / शाब्दिक रूप में पारित किया जाना चाहिए, इसे पारित करने के लिए अनुमति नहीं है 80N20Eचार मापदंडों / तारों के रूप में: 80, N, 20, E।

यह गारंटी दी जाती है कि कोने सभी अलग-अलग हैं और दोनों में से दो कोने एक एंटीपोडल पॉइंट जोड़ी बनाते हैं।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।

Comments

पहले कुछ परीक्षण मामलों के लिए सही आउटपुट 90 डिग्री और 179 डिग्री हैं। मुझे लगता है कि आप कह रहे हैं कि उन्हें हाजिर नहीं होना है, लेकिन सटीकता के कितने दशमलव स्थानों की आवश्यकता है?

— लेवल रिवर सेंट

@steveverrill कार्य को अपडेट किया गया। एक डिग्री की सटीकता पर्याप्त है।

— pawel.boczarski

@ pawel.boczarski क्या अक्षांश / देशांतर हमेशा पूर्णांक होते हैं?

— दोष

@flawr हां, मैंने टास्क को अपडेट किया।

— pawel.boczarski

Answer 1

मतलाब, 288 266 बाइट्स

यहाँ टिप्पणी संस्करण है कि क्या चल रहा है की व्याख्या करनी चाहिए:

                                  %parsing the input
for k=1:3;
    s=input('','s');              %request input
    if sum(s>57)<2;               %if we have only one letter, add arbitrary second coordinate
        s=[s,'0E'];
    end;
    S=1-2*(s(s>57)>80);           %calculate the sign of the coordinates
    s(s>57)=44;                   %replace letters with comma
    L(k,:)=eval(['[',s,']']).*S;  %evaluates string as list and multiply with signs
end;
i=[2,3,1];
                                  %calculate the angular distance between each pair of points
a=arrayfun(@distance,L(:,1),L(:,2),L(i,1),L(i,2))*pi/180;
                                  %evaluate the spherical excess
f=@(a,b,c)sum(acos((cos(a)-cos(b).*cos(c))./(sin(b).*sin(c))))-pi;
disp(f(a,a(i),a([3,1,2]))*180/pi)

पूरी तरह से गोल्फ (लाइनब्रेक हटाया जा सकता है):

for k=1:3;s=input('','s');if sum(s>57)<2;s=[s,'0E'];end;
s(s>57)=44;L(k,:)=eval([91,s,93]).*(1-2*(s(s<48)>80));end;
i=[2,3,1];p=pi/180;a=arrayfun(@distance,L(:,1),L(:,2),L(i,1),L(i,2))*p;
b=a(i);disp((sum(acos((cos(a([3,1,2]))-cos(b).*cos(a))./(sin(b).*sin(a))))-pi)/p)

Answer 2

रूबी, रेव 3 264 255 बाइट्स

महत्त्वपूर्ण परिवर्तन:

नए निरंतर r= 180 / PI को पूरे फ़ंक्शन में परिभाषित और उपयोग किया जाता है। e+ PI से आरंभ किया जाना था, इसलिए अब नीचे की ओर गिना जाता है और वापस लौटने से पहले इसे नकार दिया जाता है।

t[]समाप्त: रूबी को उस डेटा को अनुमति देता t[]है जिसे सीधे सौंपा गया थाu,v,w.

iदो के काम करने के लिए एकल लूप, ?:कार्यों के बीच टर्नरी ऑपरेटर स्विच।

कई अन्य छोटे बदलाव।

include Math
->s{r=180/e=PI
x=y=z=n=[]
9.times{|i|i<6?(u,v,w=eval(?[+s[i%3].gsub(/[NE]/,"/r,").gsub(/[SW]/,"/-r,")+"0]")
i%2<1&&x=y=z=1
n[i/2]=(z*=sin(u))+(y*=cos(v)*w=cos(u))+x*=w*sin(v)):e-=acos((n[i-7]-(c=n[i-6])*d=n[i-8])/sqrt((1-c*c)*(1-d*d)))}
-e*r}

रूबी, रेव १ १ .३ 277 बाइट्स

3 स्ट्रिंग्स की एक सरणी की आवश्यकता है।

include Math 
->s{x=y=z=n=[]
6.times{|i|t=eval(?[+s[i%3].gsub(/[NE]/,k="*PI/180,").gsub(/[SW]/,"*-1"+k)+"0]")
i%2<1&&x=y=z=1
n[i/2]=(z*=sin(u=t[0]))+(y*=cos(u)*cos(v=t[1]))+(x*=cos(u)*sin(v))}
e=-PI
3.times{|i|e+=acos((n[i-1]-n[i]*d=n[i-2])/sqrt((1-n[i]**2)*(1-d**2)))}
e/PI*180}

अवलोकन

इकाई क्षेत्र पर त्रिभुज पक्षों की लंबाई दो बिंदुओं का वर्णन करने वाले वैक्टर के बीच के कोण के बराबर होती है। लेकिन हमें उस कोण को जानने की जरूरत नहीं है। यह कोण के कोसाइन को जानने के लिए पर्याप्त है, जो डॉट उत्पाद का उपयोग करके कार्टेशियन निर्देशांक से आसानी से प्राप्त होता है।

व्याख्या

इनपुट स्ट्रिंग्स को एक सरणी के एक स्ट्रिंग प्रतिनिधित्व में परिवर्तित किया जाता है, जिसे फिर tनीचे के रूप में मूल्यांकन और संग्रहीत किया जाता है। यदि दो निर्देशांक दिए गए हैं तो अंतिम शून्य की आवश्यकता नहीं है। यदि केवल अक्षांश 90 दिया जाता है, तो शून्य की व्याख्या देशांतर के रूप में की जाती है।

Example:  70N20W --> [70*PI/180,20*-1*PI/180,0]

डॉट उत्पाद प्रपत्र के हैं a.b=ax*bx+ay*by+az*bz। जैसा कि वैक्टर सभी इकाई लंबाई के होते हैं, डॉट उत्पाद वैक्टर के बीच के कोण के कोसाइन के बराबर होता है।

उन्हें गणना करने के लिए एक लूप 6 बार इनपुट डेटा के माध्यम से दो बार गुजर रहा है। x,y,zनई गणना शुरू करने के लिए भी पुनरावृत्तियों पर 0,2,4 चर 1 पर सेट हैं। प्रत्येक पुनरावृत्ति पर इन चरों को प्रत्येक वेक्टर के x, y और z घटकों द्वारा गुणा किया जाता है, t[0],t[1]जिसमें (और गोल्फिंग कारणों के लिए भी असाइन किया गया है u,v) देशांतर और अक्षांश डेटा का उपयोग किया जाता है । चर का योग सरणी के लिए लिखा गया है n(अजीब पुनरावृत्तियों पर सही मानों द्वारा इसे अधिलेखित किए जाने पर भी कचरा मूल्य) ताकि अंत nमें 3 डॉट उत्पाद शामिल हों[a.b, c.a, b.c] ।

कोसाइन नियम के लिए, हमें कोने के बीच तीनों कोणों के कोसाइन की आवश्यकता होती है, लेकिन हमें साइन्स की भी आवश्यकता होती है। इन्हें इस रूप में प्राप्त किया जाता है sqrt(1-cosine**2)। चूंकि साइन को एक साथ गुणा किया जाता है, इसलिए अभिव्यक्ति को फिर से व्यवस्थित किया जा सकता है ताकि केवल एक कॉल sqrtकी आवश्यकता हो। यह तथ्य कि हम नहीं जानते कि साइन पॉजिटिव था या नेगेटिव कोई मायने नहीं रखता था, क्योंकि हैवेरिन का फॉर्मूला हमेशा पॉजिटिव साइन देता है। महत्वपूर्ण भौतिक मात्रा बिंदुओं के बीच की दूरी है, जो निरपेक्ष है और इसलिए हमेशा सकारात्मक होती है।

प्रत्येक पुनरावृत्ति के लिए i=0..2, हम i-1अन्य तत्वों iऔर तत्वों का उपयोग करके कोण विपरीत तत्व के लिए मान की गणना करते हैं i-2। रूबी में नकारात्मक सरणी सदस्यता इस तरह के कानूनी हैं, वे सिर्फ सरणी की शुरुआत के चारों ओर लपेटते हैं।

परीक्षण कार्यक्रम में अपराजित

उनके बीच रिक्त स्थान के साथ, एक ही लाइन पर निर्देशांक के तीन सेट की आवश्यकता होती है।

include Math
g=->s{
  n=[]         #array for dot products
  x=y=z=1      #it's required to use these variables once before the loop, for some bizarre reason
  6.times{|i|
    t=eval(?[+s[i%3].gsub(/[NE]/,k="*PI/180,").gsub(/[SW]/,"*-1"+k)+"0]")
    i%2<1&&x=y=z=1
    n[i/2]=(z*=sin(u=t[0]))+(y*=cos(u)*cos(v=t[1]))+(x*=cos(u)*sin(v))
  }

  e=-PI        #set e to -PI and begin accumulating angles
  3.times{|i|
    e+=acos((n[i-1]-n[i]*n[i-2])/sqrt((1-n[i]**2)*(1-n[i-2]**2)))
  }

e/PI*180}      #return value

puts g[gets.split]