दो बिंदुओं के बीच की दूरी एक ध्रुवीय ग्राफ चार्ट पर यात्रा करना

Question

संक्षिप्त समस्या स्पष्टीकरण

केवल दो बिंदुओं के बीच की न्यूनतम दूरी ज्ञात करने के लिए एक कार्यक्रम लिखें, जो मूल से निकलने वाली किरणों और मूल पर केंद्रित हलकों पर यात्रा कर रहा है।

परिसर का स्पष्टीकरण

अब आइए कल्पना करें कि हम एक विमान पर हैं, और इस विमान में हमें केवल विशेष तरीकों से यात्रा करने की अनुमति है। हमें मूल से निकलने वाली किसी भी किरण पर यात्रा करने की अनुमति है।

हम किसी सर्कल पर केंद्रित किसी भी सर्कल पर यात्रा कर सकते हैं

अब हमारा लक्ष्य इस विमान से एक बिंदु से दूसरे तक यात्रा करना है। हालाँकि, हम केवल एक साधारण यूक्लिडियन पथ में यात्रा नहीं कर सकते हैं, हम ऐसा केवल तभी कर सकते हैं जब बिंदु केंद्र से निकलने वाली किरण पर पड़ें।

हम इस पर यात्रा कर सकते हैं क्योंकि यह हमारी किरणों में से एक पर गिरती है।

हम मूल पर केंद्रित हलकों पर भी यात्रा कर सकते हैं।

उदाहरण

अब यहाँ चुनौती है:

हमें सबसे छोटे मार्ग में एक बिंदु से दूसरे बिंदु तक जाना है; अक्सर यह मंडलियों और किरणों पर यात्रा करने का एक संयोजन है।

हालांकि, यह दो किरणों पर भी यात्रा कर सकता है।

कभी-कभी दो रास्ते होते हैं जो न्यूनतम दूरी तय करते हैं।

संकट

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

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

(आयताकार इनपुट के साथ)

(1,1) (1,-1) -> ~ 2.22144
(0,0) (1, 1) -> ~ 1.41421
(1,0) (-0.4161 , 0.90929) -> ~ 2
(1,1) (1, 0) -> ~ 1.19961
(1,2) (3, 4) -> ~ 3.16609

Comments

क्या आयताकार या ध्रुवीय रूपों में उदाहरण परीक्षण के मामले हैं? Also: bewteen

— Angs

वे आयताकार रूप में हैं, मुझे यह स्पष्ट करना चाहिए कि

— एंडो बंदो

क्या अंतिम उदाहरण सही है? मुझे

— एंग्स

@Peter टेलर क्योंकि वे वास्तव में एक ही मार्ग नहीं हैं। इसी तरह से xy और x दिशाओं में बारी-बारी से छोटे चरणों के माध्यम से xy विमान पर 0,0 से 1,1 तक का रास्ता एक सीधा विकर्ण पथ के समान दिखाई देता है क्योंकि चरण की लंबाई शून्य हो जाती है। लेकिन विकर्ण पथ की लंबाई sqrt (2) है, जबकि चरण पथ की लंबाई हमेशा 2 होगी

— पेंगुइन

मुझे लगता है कि यदि चित्र इतने बड़े नहीं होते तो चुनौती बेहतर दिखती। वर्तमान में वे पाठ का पालन करना कठिन बनाते हैं

— लुइस मेंडो

Answer 1

हास्केल, 49 48 बाइट्स

(a!q)c r=min(q+r)$abs(q-r)+acos(cos$a-c)*min q r

उपयोग:

> let rect2polar (x,y)=(atan2 y x, sqrt(x^2+y^2))
> let test c1 c2=let [(a1,r1),(a2,r2)]=rect2polar<$>[c1,c2] in (a1!r1)a2 r2
> test (1,0) (-0.4161, 0.90929)
1.9999342590038496

एक बाइट को बचाने के लिए @Zgarb को धन्यवाद

Comments

आप (a!q)c rइसके बजाय परिभाषित करके एक बाइट बचा सकते हैं d a q c r।

— ज़र्गब

Answer 2

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

with(Math)(r,t,s,u,v=acos(cos(t-u)))=>v<2?abs(r-s)+v*min(r,s):r+s

ध्रुवीय निर्देशांक लेता है। 0 और 'के बीच के कोण को कम करने के लिए @Angs की चाल का उपयोग करता है। आयताकार निर्देशांक के लिए, कुछ इस तरह से काम करता है:

with(Math)g=(r,t,s,u,v=acos(cos(t-u)))=>v<2?abs(r-s)+v*min(r,s):r+s
with(Math)f=(x,y,v,w)=>g(hypot(y,x),atan2(y,x),hypot(w,v),atan2(y,v))

Answer 3

MATL , 22 बाइट्स

|ttsGZ}/X/bX<*|bd|+hX<

इनपुट दो जटिल संख्याओं की एक सरणी है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

|       % Implicitly input array and take absolute value of its entries
tt      % Duplicate twice
s       % Sum. This is the length of the path that follows the two radii
GZ}     % Push input again and split into the two numbers
/X/     % Divide and compute angle. This gives the difference of the angles
        % of the two points, between -pi and pi
bX<     % Bubble up a copy of the array of radii and compute minimum
*|      % Multiply and take absolute value. This is the arc part of the
        % path that follows one arc and the difference of radii
bd|     % Bubble up a copy of the array of radii and compute absolute
        % difference. This is the other part of the second path
+       % Add. This gives the length of second path
hX<     % Concatenate and take minimum to produce the smallest length.
        % Implicitly display

Answer 4

रूबी, 64 बाइट्स

पहला, मेरा सबमिशन। तर्क के साथ लंबोदर समारोह distance 1, angle 1, distance 2, angle2।

->r,a,s,b{([d=(b-a).abs,?i.to_c.arg*4-d,2].min-2)*[r,s].min+s+r}

अब यहाँ 66 बाइट्स (असाइनमेंट को छोड़कर f=) के दो अलग-अलग समाधानों के बाद 64 बाइट्स पर फिर से मेरा वास्तविक सबमिशन है।

Solution 1:Using include Math, 66 bytes excluding f=
include Math;f=->r,a,s,b{[acos(cos(b-a)),2].min*[r,s].min+(s-r).abs}

Solution 2:Using complex number to define PI instead, 66 bytes excluding f=
f=->r,a,s,b{[d=(b-a).abs,?i.to_c.arg*4-d,2].min*[r,s].min+(s-r).abs}

SUBMISSION AGAIN, 64 bytes excluding f=
f=->r,a,s,b{([d=(b-a).abs,?i.to_c.arg*4-d,2].min-2)*[r,s].min+s+r}

सबमिशन समाधान 2 पर आधारित है, लेकिन पहचान का उपयोग करता है (s-r).abs= s+r-[s,r].min*22 बाइट्स द्वारा कोड को छोटा करने के लिए, इसलिए -2कोष्ठक के अंदर।

अन्य उल्लेखनीय विशेषता का ?i.to_c.arg*4उपयोग किए बिना अभिव्यक्ति = 2 * पीआई है include Math। यदि कम परिशुद्धता स्वीकार्य है तो इसे शाब्दिक द्वारा प्रतिस्थापित किया जा सकता है।

समाधान 2 परीक्षण कार्यक्रम में टिप्पणी की

f=->r,a,s,b{          #r,s are distances, a,b are angles for points 1 and 2 respectively.                       
    [d=(b-a).abs,       #From nearer point we can take arc of length d radians perhaps crossing zero angle to the ray of the further point
    ?i.to_c.arg*4-d,    #or go the other way round which may be shorter (?i.to_c.arg*4 == 2*PI, subtract d from this.)
    2].min*             #or go through the centre if the angle exceeds 2 radians.
  [r,s].min+          #Multiply the radians by the distance of the nearer point from the origin to get the distance travelled. 
  (s-r).abs           #Now add the distance to move along the ray out to the further point.
}

#test cases per question (given as complex numbers, converted to arrays of [distance,angle]+[distance,angle] (+ concatenates.)
#the "splat" operator * converts the array to 4 separate arguments for the function.
p f[*("1+i".to_c.polar + "1-i".to_c.polar)]
p f[*("0".to_c.polar + "1+i".to_c.polar)]
p f[*("1".to_c.polar + "-0.4161+0.90929i".to_c.polar)]
p f[*("1+i".to_c.polar + "1".to_c.polar)]
p f[*("1+2i".to_c.polar + "3+4i".to_c.polar)]

उत्पादन

2.221441469079183
1.4142135623730951
1.9999342590038496
1.1996117257705434
3.1660966740274357

Answer 5

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

यह आयताकार निर्देशांक लेता है और एक सटीक प्रतीकात्मक समाधान का उत्पादन कर सकता है

Min[If[(m=Min[{p,q}=Norm/@#])>0,m*VectorAngle@@#,0]+Abs[p-q],p+q]&

उपयोग:

%/@{
{{1,1},{1,-1}},
{{0,0},{1,1}},
{{1,0},{-.4161,.90929}},
{{1,1},{1,0}},
{{1,2},{3,4}}
}

पैदावार:

N @% पैदावार:

* 11.221441469, 1.414213562, 1.999934259, 1.199611726, 3.166096674}

Comments

निफ्टी! यदि आप प्रतीकात्मक मार्ग पर जा रहे हैं, तो आप टेस्ट केस {1,0} {- 4161, .90929} को {1,0} {कॉस (2), पाप (2)}

— एंडो बैंडो

Answer 6

पायथन 2, 164 126 125 132 बाइट्स:

def A(a,b,c,d,p=3.1415926535):z=abs(a-c);M=lambda f:2*p*f*abs(b-d)/360.0;print min((a==c)*min(a+c,M(a))+(b==d)*z or'',M(a)+z,M(c)+z)

मैं वर्तमान में इसे और अधिक गोल्फिंग में देख रहा हूं, हालांकि। ध्रुवीय निर्देशांक स्वीकार करता है। प्रारूप में बुलाया जाना चाहिए A(r1,θ1,r2,θ2)। 12महत्वपूर्ण आंकड़ों तक सटीक एक अस्थायी बिंदु मान आउटपुट करता है ।

यह ऑनलाइन की कोशिश करो! (Ideone)

एक सरल, सीधा कार्यान्वयन, जिसमें अधिकतम 3 मान वाले सरणी से बाहर न्यूनतम मूल्य के STDOUT की गणना और आउटपुट होता है:

1. या तो r1+r2दो अंकों के योग का न्यूनतम मूल्य ( ) या चाप की लंबाई दो बिंदुओं को जोड़ने वाली iff r1==r2 ;
2. दो दूरियों के बीच का अंतर ( abs(r1-r2)) iff θ1==θ2 (अर्थात दो बिंदु आपस में टकराते हैं);
3. यदि पिछली 2 वस्तुओं में से कोई भी जोड़ा नहीं गया है, तो एक स्ट्रिंग ( '') के रूप में जाहिरा तौर पर अजगर में एक स्ट्रिंग किसी भी पूर्णांक से अधिक है ;
4. और दूरियों से दिए गए 2 अंतिम मूल्य एक वृत्त और दो बिंदुओं के बीच एक किरण और इसके विपरीत यात्रा करते हैं।

Comments

क्यों नहीं math.pi?

— user202729

Answer 7

वोल्फ्राम भाषा (गणितज्ञ) , 47 बाइट्स

MinMax@Abs@{##}.{Min[Abs[Arg@#-Arg@#2]-1,1],1}&

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

(वर्तमान 66-बाइट उत्तर धड़कता है)

2 जटिल संख्याओं के रूप में इनपुट लें।

यदि इनपुट प्रतीकात्मक है तो कुछ समस्याएँ हो सकती हैं। (जैसे, Cos@2 + I Sin@2)