एन, एस, ई और डब्ल्यू की एक स्ट्रिंग को देखते हुए, 5 दशमलव स्थानों के लिए सही एक असर (डिग्री में उत्तर से कोण)।

में पारंपरिक कम्पास अंकन , एक स्ट्रिंग केवल 2 (NNW या ESE) की तरह इन पात्रों की से मिलकर बना है। यहां आपको उन स्ट्रिंग्स को भी स्वीकार करना होगा जिनमें सभी 4 (जैसे WNNNSE) शामिल हैं । केवल 2 प्रतीकों का उपयोग करने से मनुष्य सहजता से अर्थ को समझ सकता है। 4 प्रतीकों की अनुमति देना पढ़ने के लिए भयानक बनाता है, लेकिन किसी दिए गए सटीकता के लिए असर का वर्णन करने के छोटे तरीकों की अनुमति देता है।

(जैसा कि user2357112 द्वारा टिप्पणियों में बताया गया है , यह पता चलता है कि आप किसी भी दिए गए असर के लिए यह साबित कर सकते हैं कि 4 प्रतीक स्ट्रिंग की लंबाई 2 प्रतीक स्ट्रिंग के समान होगी, इसलिए मैंने इस चुनौती को गलत धारणा पर आधारित किया है। उम्मीद है कि व्यावहारिक उद्देश्य की यह कमी चुनौती के आपके आनंद से कम नहीं है ...)

सटीक विधि नीचे वर्णित है, और पारंपरिक अंकन के बराबर है (यह इसे बदलने के बजाय उस पर फैलता है)।

इनपुट

इनपुट एकल स्ट्रिंग है जिसमें केवल वर्ण होते हैं NESW।
यदि आप चाहें तो इनपुट वर्णों का एक अनुक्रम हो सकता है, बशर्ते इसमें कोई पूर्वप्रक्रिया शामिल न हो। उदाहरण के लिए, [N, [E, [S, [W]]]]प्रसंस्करण के क्रम में मदद करने के लिए एक नेस्टेड सूची लेने की अनुमति नहीं है।
विभिन्न पात्रों को लेने की अनुमति नहीं है। आप 1234इसके बजाय एक स्ट्रिंग नहीं ले सकते NESW।

उत्पादन

आउटपुट एक दशमलव संख्या या स्ट्रिंग का प्रतिनिधित्व होना चाहिए (तर्कसंगत / अंश नहीं)।
ट्रेलिंग शून्य को प्रदर्शित करने की आवश्यकता नहीं है। यदि असर होता है 9.00000, तो आउटपुट 9भी 5 दशमलव स्थानों पर सही होता है।
आउटपुट रेंज [0, 360) में है। यानी 0 सहित, लेकिन 360 को छोड़कर।
आउटपुट को 5 दशमलव स्थानों पर गोल करके सुधार की जाँच की जाती है। यदि असर 0.000005 है, तो यह 0.00001 तक होता है। आउटपुट 0.00001 और 0.000005 दोनों सही हैं।
कुछ इनपुट के लिए वैज्ञानिक संकेतन में आउटपुट स्वीकार्य है। उदाहरण के लिए, के 1e-5बजाय 0.00001।

रूपांतरण

एकल वर्ण कम्पास अंक N, E, S, और Wपत्र व्यवहार करने 0, 90, 180, और 270 डिग्री क्रमशः।
इनमें से किसी एक को स्ट्रिंग में परिणत करने से परिणाम होता है जो एकल वर्ण के असर और मूल स्ट्रिंग के असर को द्विभाजित करता है।
दो संभावित बाइसेक्टिंग बियरिंग्स के सबसे पास को चुना जाता है, ताकि NE 45 डिग्री का प्रतिनिधित्व करे, 225 डिग्री का नहीं।
यह असंदिग्ध है सिवाय इसके कि कोण को द्विभाजित किया जाए जहां 180 डिग्री है। इसलिए NS, SN, WE, और EWअपरिभाषित बीयरिंग के अनुरूप है, और इनपुट इनमें से किसी भी में खत्म हो कभी नहीं होगा। हालांकि वे इनपुट स्ट्रिंग में कहीं और दिखाई दे सकते हैं, क्योंकि इससे कोई अस्पष्टता नहीं होती है।
यदि अंतिम दो वर्ण समान हैं, तो अंतिम वर्ण निरर्थक हो जाएगा क्योंकि द्विभाजन उसी असर को लौटा देगा। चूंकि यह नोटेशन में कुछ भी नहीं जोड़ता है, इसलिए आपके कोड को इसे संभालने की आवश्यकता नहीं है। इसलिए NN, EE, SS, और WWअपरिभाषित बीयरिंग के अनुरूप है, और इनपुट इनमें से किसी भी में खत्म हो कभी नहीं होगा। हालांकि वे इनपुट स्ट्रिंग में कहीं और दिखाई दे सकते हैं।

उदाहरण

N: 0
E: 90
S: 180
SE: halfway between S and E: 135
NSE: halfway between N and SE: 67.5
NNSE: halfway between N and NSE: 33.75
NNNSE: halfway between N and NNSE: 16.875
NNNNSE: halfway between N and NNNSE: 8.4375

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

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

टेस्ट केस आउटपुट को 5 दशमलव स्थानों पर दिखाया जाता है, और सटीक रूप से सटीक भी। दोनों वैध आउटपुट हैं।

WNE 337.5 337.5
WEN 337.5 337.5
WEWEWEWEWEWEWEWEWEWEWEN 330.00001 330.000007152557373046875
NESWNESWNESWNESWNESWNESWNESW 90 89.99999932944774627685546875
NNNNNNNNNNNNNNNNNNNNNNNE 0.00001 0.0000107288360595703125
NNNNNNNNNNNNNNNNNNNNNNNW 359.99999 359.9999892711639404296875
SNNNNNNNNNNNNNNNNNNNNNNNE 90.00001 90.00000536441802978515625
SNNNNNNNNNNNNNNNNNNNNNNNW 269.99999 269.99999463558197021484375

स्कोरिंग

यह कोड-गोल्फ है । स्कोर बाइट्स में स्रोत कोड की लंबाई है, और सबसे छोटी जीत है।

^{पांडित्य-प्रदर्शन}

^{मैंने यह सोचने की गलती की कि "नॉर्थ बाय नॉर्थ वेस्ट" एक वैध कम्पास दिशा थी। एक खुश गलती, क्योंकि इसने एक चुनौती विचार का नेतृत्व किया, लेकिन मैंने तब विकिपीडिया पृष्ठ से खोजा :}

^{"अल्फ्रेड हिचकॉक 1959 की फिल्म, नॉर्थवेस्ट द्वारा उत्तर, वास्तव में 32-विंड कम्पास पर एक दिशा बिंदु नहीं है, लेकिन फिल्म में नॉर्थवेस्ट एयरलाइंस का संदर्भ है। ”}

^{यह भी पता चला है कि इस चुनौती के लिए इस्तेमाल की जाने वाली विधि केवल 16 बिंदु वाले कम्पास के साथ पारंपरिक कम्पास बिंदुओं के अनुरूप है। उस पृष्ठ पर वर्णित 32-पवन कम्पास सूक्ष्म रूप से अलग है और मैंने इस चुनौती के लिए अपने अस्तित्व को आसानी से अनदेखा कर दिया है।}

^{अंत में, जो कोई भी सोचता है कि मुझे "दक्षिण पूर्व" के बजाय "दक्षिण पूर्व" का उपयोग करना चाहिए,।}

code-golf

— trichoplax
स्रोत

WNNNSE<= आपके पोस्ट के प्रारंभ में इस उदाहरण प्रविष्टि के लिए आउटपुट क्या होगा? यह मेरे लिए अमान्य लगता है, लेकिन यह बताना मुश्किल है।

— तेंसिबाई

@Tensibai इनपुट के WNNNSEलिए आउटपुट होगा 323.4375। वॉकथ्रू के लिए उदाहरण अनुभाग देखें जो इस मामले में उसी तरह लागू होगा।

— ट्राइकोप्लाक्स

क्या इनपुट f(N,N,N,S,E)ठीक है?

— कार्ल नेफ

@KarlNapf मैंने स्पष्ट करने के लिए इनपुट अनुभाग का विस्तार किया है। अगर मैं सही तरीके से समझूं, तो कई तर्कों के साथ आपका उदाहरण इनपुट वर्णों के अनुक्रम के बराबर लगता है, इसलिए यह स्वीकार्य होगा।

— ट्राइकोप्लाक्स

2

"4 प्रतीकों की अनुमति देना इसे पढ़ने के लिए भयानक बनाता है, लेकिन किसी दिए गए सटीकता के लिए असर का वर्णन करने के छोटे तरीकों की अनुमति देता है।" - क्या अापको उस बारे में पूर्ण विशवास है? ऐसा लगता है कि सभी निविष्टियाँ जो समान असर का वर्णन करती हैं, उनकी लंबाई समान होती है, क्योंकि यदि आप प्रत्येक को 0 से 1 तक एक डाईएडिक परिमेय प्रदान करते हैं, तो N> 1 के साथ एक लंबाई-एन स्ट्रिंग हमेशा विभाजक 2 ^ (N के साथ एक डायडिक परिमेय से मेल खाती है) +1) सबसे कम शब्दों में। इसके अलावा, एक असर में 2 से अधिक अलग-अलग अक्षरों की अनुमति देना कोई अभिव्यंजक शक्ति नहीं जोड़ता है; 3 या 4 अक्षरों के साथ व्यक्त किसी भी असर को 2 के साथ व्यक्त किया जा सकता है

— user2357112

13

जावास्क्रिप्ट (ईएस 6), 84 80 78 74 72 बाइट्स

@ बाइट के लिए @Titus, 1 धन्यवाद के लिए एक बाइट धन्यवाद सहेजा गया

f=([c,...s],b="NESW".search(c))=>b*90-(s[0]?(b-=f(s)/90)-4*(b*b>4):0)*45

इसमें थोड़ा समय लगा, लेकिन मुझे लगता है कि मैंने आखिरकार फॉर्मूला पूरा कर लिया है ...

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

f=([c,...s],b="NESW".search(c))=>b*90-(s[0]?(b-=f(s)/90)-4*(b*b>4):0)*45
g=(s,n)=>console.log('f("'+s+'"):',f(s),"expected:",n)

g("N", 0)
g("NE", 45)
g("E", 90)
g("SE", 135)
g("S", 180)
g("SW", 225)
g("W", 270)
g("NW", 315)
g("WNE", 337.5)
g("WEN", 337.5)
g("WEWEWEWEWEWEWEWEWEWEWEN", 330.00001)
g("NESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESW", 90)
g("NNNNNNNNNNNNNNNNNNNNNNNE", 0.00001)
g("NNNNNNNNNNNNNNNNNNNNNNNW", 359.99999)
g("SNNNNNNNNNNNNNNNNNNNNNNNE", 90.00001)
g("SNNNNNNNNNNNNNNNNNNNNNNNW", 269.99999)

Expand snippet

व्याख्या

चलो सबसे सरल मामले से शुरू करते हैं: एकल-चार स्ट्रिंग। परिणाम केवल इसकी (0-अनुक्रमित) स्थिति स्ट्रिंग में NESW, 90 से गुणा है।

दो-चार स्ट्रिंग के लिए, परिणाम पहले चार के परिणाम और दूसरे के परिणाम के बीच में आधा होता है। हालाँकि, वहाँ एक पकड़ है: अगर दोनों के बीच पूर्ण अंतर 180 (जैसे NWया WN) से अधिक है , तो हमें कोण से 180 होना चाहिए ताकि यह विपरीत दिशा को इंगित न करे।

किसी भी लंबे स्ट्रिंग के लिए, परिणाम पहले चार के परिणाम और बाकी स्ट्रिंग के परिणाम के बीच आधा रह जाता है। इसे निम्न तरीके से सामान्यीकृत किया जा सकता है:

यदि इनपुट एक एकल चर है, तो इसके सूचकांक को स्ट्रिंग NESWसमय 90 में वापस करें।
अन्यथा, पहले चर के सूचकांक को स्ट्रिंग NESWसमय 45 में वापस करें, साथ ही बाकी स्ट्रिंग के परिणामस्वरूप आधा; अतिरिक्त 180 जोड़ें यदि दोनों के बीच पूर्ण अंतर 90 से अधिक है।

— ETHproductions
स्रोत

स्ट्रिंग से पहले चरित्र को काटने का उत्कृष्ट तरीका! यदि आप 45 से विभाजित मूल्यों के साथ गणना करते हैं तो आप एक बाइट बचा सकते हैं।

— टाइटस

@Titus मैं उस तकनीक के साथ 2 बाइट्स बचा सकता हूं, धन्यवाद!

— ETHproductions

1

searchइसके बजाय indexOfआप एक बाइट को बचाने के लिए।

— नील

@ नील फिर से धन्यवाद! मैं समीकरण को पूरी तरह से फिर से व्यवस्थित करके तीन और बंद करने में कामयाब रहा।

— ETHproductions

10

सी # 6, 226 217 207 185 बाइट्स

using System.Linq;double N(string s){double b=f(s.Last());foreach(var c in s.Reverse()){b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0))/2;b=(b+4)%4;}return b*90;}int f(char x)=>"NESW".IndexOf(x);

संपादित करें: -10 बाइट्स ETHproductions की सबमिशन
-22 बाइट्स से "उधार" विचार @ धन्यवाद के लिए

Ungolfed

// Call this method
double N(string s){
    // Initialize bearing with last direction
    double b=f(s.Last());
    // Do backward. Doing last direction once more doesn't impact result
    foreach(var c in s.Reverse()){
        // Average current bearing with new bearing, adjusted with wrapping
        b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0))/2;
        // Make bearing back to range [0,4)
        b=(b+4)%4;
    }
    // Change from "full circle = 4" unit to degree
    return b*90;
}
// helper method to convert direction to bearing. This returns bearing with full circle = 4.
int f(char x)=>"NESW".IndexOf(x);

— लिंक एनजी
स्रोत

मुझे लगता है कि आप% 0 का उपयोग करके अपनी सीमा समायोजन को [0,360) तक कम कर सकते हैं

— ट्राइकोप्लाक्स

@trichoplax वोनिमैट कि दशमलव में कटौती?

— टाइटस

1

@Titus C #% फ़्लोट के साथ-साथ पूर्णांकों के लिए भी काम करता है ।

— ट्राइकोप्लाक्स

1

के b=(b+360)%360;बजाय के साथ 10 बाइट्स सहेजें b+=b>360?-360:b<0?360:0;। एक और 12 बाइट्स को 90 से विभाजित करके सब कुछ बचाएं return b*90;।

— टाइटस

1

यहां 10 और बाइट्स हैं: दो असाइनमेंट को मर्ज करें और ब्रेस को हटा दें: b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0)+8)/2%4;फिर +8टर्नरी परिणामों को वितरित करेंb=(b+f(c)+(b-f(c)>2?12:f(c)-b>2?4:8))/2%4;

— टाइटस

8

PHP, 95 88 86 100 127 104 101 बाइट्स

-7 बाइट्स नल coalescing ऑपरेटर के साथ
-2 बाइट्स की जगह नहीं N(और अधिक, क्योंकि यह अनुवाद को लूप सिर पर लगाने की अनुमति देता है: Nसत्य है, लेकिन 0गणना में मूल्यांकन करता है ।)
+41 बाइट्स को ठीक करने के लिए बाइट्स ( खांसी )
-7 बाइट्स सीधे और -16 अप्रत्यक्ष रूप से @ ETHproductions। कोड से प्रेरित
-3 बाइट्स strtrको मेरे एक बिट जुगलिंग के साथ बदलकर

for($i=strlen($s=$argv[1]);$i--;$p=($q+$p=$p??$q)/2+2*(abs($q-$p)>2))$q=ord($s[$i])/.8+3&3;echo$p*90;

यह आधिकारिक तौर पर पहली बार है कि मैं अशक्त सह-संचालन ऑपरेटर का उपयोग करता हूं। साथ चलाना -r।

PHP 7.1

आगामी PHP संस्करण में नकारात्मक स्ट्रिंग ऑफसेट 12 बाइट्स बचाएगा: के साथ और साथ
बदलें ।strlen($s=$argv[1])0$s$argv[1]

सभी के लिए मुफ्त बाइट्स (लगभग):

0,90,180,270 के बजाय 0,1,2,3 के साथ गणना करने और अंतिम परिणाम को 90 के साथ गुणा करने से दो बाइट्स बचेंगे और शायद आगे गोल्फ की अनुमति होगी।
वर्णों के ASCII कोड में कुछ पैटर्न हैं। अपनी भाषा में इनमें से एक का प्रयास करें:
- (a/2%6+2)%5
- a<87?a/2&3^3:3 या a/2&3^3*(a<87)
- a&1?a&2|a/4&1:0
- a/.8-1&3

— टाइटस
स्रोत

5

पायथन 3, 133 113 बाइट्स

केवल @ L3viathan के उत्तर में सुधार करना क्योंकि मैंने अभी यह खाता बनाया है और इसलिए अभी तक टिप्पणी नहीं कर सकता।

d={"N":0,"E":.5,"S":1,"W":1.5}
def B(s):
 b=d[s[-1]]
 for c in s[::-1]:b=(b+d[c])/2+(abs(b-d[c])>1)
 return b*180

— Moonocababa
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है, और अच्छा सुधार ...

— ट्राइकोप्लाक्स

मैंने आपका उत्तर नहीं देखा, लेकिन टाइटस के पास एक समान विचार था, साथ ही मेरे पास एक और था, मैं अब नीचे 98 पर हूँ :)

— L3viathan

5

05AB1E ,48 42 37 32 बाइट्स

एमिगा के लिए 6 बाइट्स बचाए गए। टाइटस के विचार के लिए 5 बाइट्स की बचत की गई, [0,4] रेंज पर काम करने के लिए और अंत में 90 से गुणा करें। प्राचीन ब्योरे / मोडुलो मेटामोर्फोसिस की अदनान की महारत के लिए 5 बाइट्स का धन्यवाद।

इसलिए प्रत्येक कोण को पूरे निष्पादन के दौरान [0,360 [से सीमा [0,4] तक घटाया जाता है। परिणाम को फिर 90 से गुणा किया जाता है और प्रदर्शित किया जाता है।

Ç30^5%R¬U¦vXy+;DX-Ä0›2*+4%U}X90*

It can be divided into two sequentially called subprograms.
First program: convert input string into an array of the corresponding angles in range [0,4[
Ç      Take the ascii value of all input characters
 30^5% Dark ascii manipulation that yields [0,1,2,3] for [N,E,S,W]

Now we have an array of integers in range [0,4[.

Second program: actually compute the final angle
R                          Reverse the array
 ¬                         Take the first value (the last of the non-reversed array)
  U                        Pop it from the stack and set X to the same value
   ¦                       Strip the first element
    v                      For each remaining element
     Xy+;                  Compute the average value between the leftmost value and X
         DX-Ä0›            Push 1 if angular distance cast to integer is > 0 (i.e. if it is >= 1), 0 otherwise. It's equivalent to checking >= 90 degrees
               2*+         Multiply by 2 (=2 if angular distance is >= 1 and 0 otherwise) and add it to the formerly computed average value. It's equivalent to multiplying by 180
                  4%       Perform mod 4. It's equivalent to performing mod 360
                    U      Store the result back to X
                     }     End for, mandatory if input has only one character
                      X90* Push X*90 and implicitly display it

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

गोल्फ की संभावित कुल्हाड़ियों:

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

— Osable
स्रोत

1

प्रतीत नहीं होता है NNNNNNNNNNNNNNNNNNNNNNNEऔर SNNNNNNNNNNNNNNNNNNNNNNNEमामलों के परीक्षण पर अनुरोधित परिणाम देने के लिए ।

— एमिगा

2

अजीब। अब मैं भी करता हूं। मुझे गलत या कुछ और करना चाहिए, क्षमा करें। आप नीचे दिए गए कोड को छोटा कर सकते हैं v"NESW"yk90*})R¬U¦vXy+;DX-Ä89›180*+360%U}X।

— Emigna

1

महान व्याख्या! यह ध्यान देने योग्य हो सकता है कि 89›वास्तव में इसका मतलब है कि पूर्णांक का हिस्सा 89 से अधिक है, जो यह कहने के बराबर है कि पूर्ण संख्या 90 से अधिक या इसके बराबर है (जो अभी भी ठीक काम करता है क्योंकि वास्तव में 90 कभी भी नहीं होना चाहिए)। वर्तमान में समझाए गए कोड में टिप्पणी यह ध्वनि देती है जैसे कि यह 89 से अधिक के लिए जाँच कर रहा है, जबकि आपका कोड परीक्षण मामलों को पास करता है इसलिए स्पष्ट रूप से 90 से अधिक के लिए जाँच कर रहा है।

— ट्राइकोप्लाक्स

1

मैंने स्पष्टीकरण को संपादित किया, लेकिन मैंने लिखा "कास्ट टू पूर्णांक" क्योंकि मुझे यकीन नहीं है कि ऑपरेटर ›को नकारात्मक फ्लोटिंग पॉइंट मानों के लिए कैसे व्यवहार करना चाहिए। यहां कोई समस्या नहीं है क्योंकि यह पूर्ण मूल्य पर काम करता है, लेकिन मैं ऑपरेटर पर बहुत मजबूत धारणाएं नहीं बनाना पसंद करता हूं।

— ओब्सेबल

1

आप बदल सकते हैं v"NESW"yk})के साथ Ç30^5%:)

— अदनान

5

पायथन 3, 146 145 117 107 97 94 93 92 बाइट्स

f(s):u='NESW'.find(s[0])*90;return(u+f(s[1:]))/2+180*(abs(u-‌f(s[1:]))>180)if s[1:]else u

fस्ट्रिंग के साथ कॉल करें ।

— L3viathan
स्रोत

आपके पास दो ...0elseवे SyntaxErrors फेंक नहीं सकते हैं ।

— जोनाथन एलन

@JonathanAllan आप पायथन के किस संस्करण का उपयोग कर रहे हैं? मैं 3.5.2 पर हूं और यह काम करता है।

— 183 पर L3viathan

मैंने इसे 3.3.3 पर चलाया - क्या आप elseऔर के बीच की जगह -भी निकाल सकते हैं ? (३.३.३ में कर सकते हैं)

— जोनाथन एलन

@JonathanAllan हाँ मैं कर सकता हूँ! धन्यवाद, जो मुझे एक और बाइट बचाता है।

— L3viathan

2

@Titus d.findकर सकते हैं, मैं एक मिनट पहले सटीक विचार था; अद्यतन उत्तर देखें।

— L3viathan 12

5

सी, 184 बाइट्स

double h(char c){return ((c=='E')+(c=='S')*2+(c=='W')*3);}double d(char*s){double f=h(*s);if(s[1]){double t=f;f=(f+d(s+1)/90)/2;if(((t-f)>1)||((f-t)>1))f+=2;if(f>=4)f-=4;}return f*90;}

Ungolfed

// a helper function
double direction_(char ch)
{
    if (ch=='N')
        return 0.;
    else if (ch=='E')
        return 90.;
    else if (ch=='S')
        return 180.;
    else
        return 270.;
}

// this is the main function to call
double direction(char* str)
{
    double fAngle = direction_(str[0]);
    if (str[1])
    {
        double tmp = fAngle + direction(str+1);
        if (tmp>=360.)
            tmp-=360.;
        tmp/=2;

        if (((tmp-fAngle)>90.) || ((tmp-fAngle)<-90.))
        { //  check if we need to take the "other side"; if the resulting angle is more than 90 degrees away, we took the wrong on
            if (tmp>=180.)
                tmp-=180.;
            else
                tmp+=180.;
        }
        fAngle = tmp;
    }
    return fAngle;
}

— इयाल लेव
स्रोत

लगता है कि फ्लोट का उपयोग करना, आपको आवश्यक सटीकता नहीं देता है।

— ईयेल लेव

4

PPCG में आपका स्वागत है! : D

— mbomb007

कार्यों के नाम एक-दूसरे के साथ संघर्ष नहीं करेंगे (क्योंकि नाम दोनों हैं d)?

— clismique

@qwerp, विभिन्न हस्ताक्षर (एक चार लेता है *, अन्य केवल चार लेता है)

— इयाल लेव

2

फ़ंक्शन नाम सी में नाम नहीं हैं, जैसा कि वे सी ++ में हैं, इसलिए आपको उनमें से एक का नाम बदलने की आवश्यकता है यदि आप इसे सी करना चाहते हैं

— क्लैस लिंडबैक

3

आर, 172 146 बाइट्स

z=rev((0:3*90)[match(scan(,""),c("N","E","S","W"))]);p=z[1];l=length(z);for(i in 2:l)p=(p+z[i])/2+(abs(p-z[i])>180)*180;if(l<2)p=z;sprintf("%f",p)

Ungolfed

z=rev((0:3*90)[match(scan,""),c("N","E","S","W"))]); #1
p=z[1];                                              #2
l=length(z)                                          #3
for(i in 2:l)p=(p+z[i])/2+(abs(p-z[i])>180)*180;     #4
if(l<2)p=z                                           #5
sprintf("%f",p)                                      #6

व्याख्या की

स्टड से इनपुट पढ़ें
- सूचकांक द्वारा इनपुट से मिलान करें c("N","E","S","W")
- मिलान किए गए सूचकांकों से: डिग्री के वेक्टर 0:3*90(के बजाय c(0,90,180,270)) से मेल खाते हैं
- रिवर्स और स्टोर के रूप में z
pइनपुट में अंतिम चार के बराबर डिग्री के लिए प्रारंभिक
के रूप में इनपुट की लंबाई स्टोर करें l
Iteratively, दो संभव द्विभाजन बीयरिंगों के निकटतम गणना करें।
यदि केवल एक इनपुट दिया जाता है, तो सेट pकरेंz
प्रारूप और प्रिंट

आर-फिडल पर परीक्षण के मामलों की कोशिश करें (ध्यान दें कि यह scanआर-फिडल पर काम नहीं करने के कारण एक फ़ंक्शन है )

— Billywob
स्रोत

बशर्ते कि आउटपुट 5 दशमलव स्थानों के लिए सही है, आपको राउंडिंग करने की आवश्यकता नहीं है। चुनौती से: Outputs 0.00001 and 0.000005 are both correct.इसलिए आपको

— चक्कर

@trichoplax मैं समझता हूँ। क्या इनपुट भी स्ट्रिंग वर्णों का एक वेक्टर हो सकता है। c("N","N","E")के बजाय "NNE"? यह एक गैर-नेस्टेड अजगर सूची के बराबर है ["N","N","E"]।

— बिलीवोब

हाँ। मैंने "अनुक्रम" का उद्देश्य सरणियों, वैक्टरों, सूचियों, ट्यूपल्स जैसी चीजों को शामिल करने के लिए एक सामान्य शब्द माना।

— ट्राइकोप्लाक्स

1

मुझे लगता है कि आप 4 बाइट्स बचा सकते हैं यदि आप सब कुछ 90 और प्रिंटफ (पी * 90) से विभाजित करते हैं।

— टाइटस

3

हास्केल, 109 105 103 बाइट्स

h=180
a#b|abs(a-b)<h=n|n>h=n-h|1>0=n+h where n=(a+b)/2 -- calculates the new "mean" on the cirlce
f 'N'=0                                          -- translates characters to angles
f 'E'=90
f 'S'=h
f _=270
foldr1(#).map f                                  -- traverses the whole string

-2 बाइट @xnor के लिए धन्यवाद!

— flawr
स्रोत

fलंबे समय के लिए संपूर्ण सूची दिखाई देती है, लेकिन मुझे कुछ भी छोटा पाने में परेशानी हो रही है। क्लोज़ेस्ट मुझे मिला f c=90*until(\i->"NESW"!!i==c)(+1)0(35)। मुझे लगता है कि आप की जगह ले सकता 'W'साथ _।

— xnor

हाँ, मुझे भी उम्मीद थी कि कुछ छोटा होगा, लेकिन कुछ भी नहीं मिला। के लिए धन्यवाद _!

— दोष

3

Dyalog एपीएल , 55 45 38 बाइट्स

समाधान

आवश्यकता है ⎕IO←0, जो कई प्रणालियों पर डिफ़ॉल्ट है। दिशा के लिए पूछता है।

360|÷○÷180×12○(+÷(|+))/¯12○○2÷⍨'NES'⍳⍞

व्याख्या

समस्या को हल चला जाता है एक जटिल संख्या के लिए प्रत्येक अक्षर परिवर्तित करके 1∠ θ ⇔ एक + ख · मैं , तो हर कदम पर दाएँ-से-बाएँ से एक राशि में कमी (एपीएल की विशेष क्षमता), जबकि सामान्य कर। अंतिम θ तो डिग्री में बदला जाएगा और [0, 360) के भीतर होने का सामान्यीकृत है:

'NES'⍳⍞"एनईएस" में प्रत्येक इनपुट पत्र के सूचकांक; एन → 0, ई → 1, एस → 2, कुछ और → 3

○2÷⍨रेडियन में कोणों में परिवर्तित; θ = π · ^एक्स / ₂

¯12○यूनिट सर्कल पर जटिल संख्या में परिवर्तित; ई ^{मैं · θ}

(... के )/साथ सूची को कम करें ... (यानी तत्वों के बीच फ़ंक्शन सम्मिलित करें ...)

+÷(|+)... सामान्यीकृत राशि; ^{एक्स _{n - 1} + x _n} / _{| x _{n - 1} + x _n} |

12○कोण में परिवर्तित; θ

÷○÷180×डिग्री में परिवर्तित; ¹ / _{π · ¹ / _{180 · एक्स}}

360| विभाजन शेष जब 360 से विभाजित

TryAPL ऑनलाइन!

उपाख्यान

यदि इनपुट और आउटपुट ऑर्थोगोनल कॉम्प्लेक्स इकाइयों के रूप में था, तो संपूर्ण समाधान सिर्फ होगा:

(+÷(|+))/

बाकी कोड इनपुट और फॉर्मेटिंग आउटपुट को पार्स कर रहा है।

— एडम
स्रोत

मुझे लगता है कि परीक्षण के आउटपुट 5 दशमलव स्थानों के लिए चुनौती से मेल नहीं खाते हैं, जिससे यह अमान्य हो जाता है। क्या Dyalog APL में दोहरी सटीकता का उपयोग करने का विकल्प है?

— ट्राइकोप्लाक्स

@trichoplax हाँ, ⎕FR←1287128 बिट फ़्लोट का उपयोग करता है, लेकिन TryAPL इसकी अनुमति नहीं देता है।

— शाम

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

— ट्राइकोप्लाक्स

@trichoplax वास्तव में, TryAPL दोहरी सटीकता का उपयोग करता है, लेकिन आपके परीक्षण के मामले 53 बिट्स से अधिक की त्रुटियों को जमा करते हैं।

— 16

यदि यह दिखाया जा सकता है कि IEEE 754 मानक की व्याख्या में अंतर के कारण अंतर है, जो अभी भी मानक अनुरूप हैं, तो मैं परीक्षण मामलों को समायोजित कर दूंगा ताकि यह सुनिश्चित हो सके कि दोनों व्याख्याएं 5 दशमलव स्थानों पर समान परिणाम दें। मैंने परीक्षण मामलों को इस तरह चुना कि उन्होंने फ्लोट (दोहरी परिशुद्धता) और मनमाना परिशुद्धता दशमलव दोनों के लिए पायथन में 5 दशमलव स्थानों पर एक ही परिणाम दिया। मैं इसे देखूंगा।

— ट्राइकोप्लाक्स

2

आम लिस्प, 347 327 बाइट्स

कुछ दूर ले जाने के लिए @Titus का धन्यवाद

यह शायद अधिक गोल्फ हो सकता है, लेकिन कम से कम यह काम करता है (मुझे लगता है):

(defun d(c)(if(eql c #\N)0(if(eql c #\E)1(if(eql c #\S)2(if(eql c #\W)3)))))(defun m(a b)(if(> a b)(rotatef a b))(if(<(+(- 4 b)a)(- b a))(+(/(+(- 4 b)a)2)b)(+(/(- b a)2)a)))(defun f(s)(let((c))(setf c(d(char s(1-(length s)))))(do((a)(p(-(length s)2)(1- p)))((< p 0))(setf a(char s p))(setf c(m(d a)c)))(format t"~5$"(* c 90))))

उपयोग:

* (f "WNE")
337.50000
NIL

समारोह dएक चरित्र लेता है N, E, W, या Sऔर रिटर्न उचित डिग्री। फ़ंक्शन mको दो दिए गए निर्देशों का उपांग संयुक्त डिग्री प्राप्त होता है। फ़ंक्शन fप्रदान किए गए स्ट्रिंग के माध्यम से पुनरावृत्त करता है, उपयुक्त डिग्री की गणना करता है, और इसे एक अस्थायी बिंदु के रूप में प्रिंट करता है।

— artificialnull
स्रोत

मेरा LISP जंग खा रहा है, लेकिन 6 बाइट्स को बचाने के लिए सब कुछ 90 से विभाजित कर सकता है?

— टाइटस

@ मुझे लगता है कि यह होगा। मुझे कुछ अन्य सुधारों का एहसास हुआ है, इसलिए मैं इसे तब

— कृत्रिम

2

Befunge, 183 181 175 बाइट्स

>~#+:#25#%6*#/`#2_$>5%4*:00p"Z}"4*:***20g#v_+2/00g10g-:8`\0\-8`+!v
v5:+*:*:"d"/+55+5$_^#!:\p01/**:*4"}Z":p020<%**:*"(2Z"+**5*:*"0}"!<
>5>+#<%#56#58#:*#/+\#5:#5_$$$,,,".">:#,_@

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

व्याख्या

यह अन्य उत्तरों में से कई के लिए एक समान एल्गोरिथ्म का अनुसरण करता है, केवल यह निश्चित बिंदु गणनाओं का उपयोग कर रहा है जो पूर्णांक के साथ उत्सर्जित होते हैं क्योंकि Befunge फ्लोटिंग बिंदु नहीं है।

ASCII-to-int दिनचर्या के लिए @Titus का धन्यवाद ।

 ~ : 5 6* ` _$        while ((c = getchar()) > 30)  // ends with any ctrl char or EOF
> + 2 %6 / 2            push(c / 2 % 6 + 2)         // partial conversion to int

                      do {
  5%                    dir = pop() % 5             // completes the conversion to int   
  4*:00p                dir *= 4; lowres_dir = dir  // used by the 180-flip calculation
  "Z}"4*:***            dir *= 22500000             // this is 90000000 / 4 
  20g_                  if (!first_pass) {
    +2/                   dir = (dir+last_dir)/2    // last_dir is second item on stack
    00g10g-               diff = lowres_dir - last_lowres_dir
    :8`\0\-8`+!!          flip = diff>8 || -diff>8
    "}0"*:*5**+           dir += flip * 180000000   // add 180 degrees if we need to flip
    "Z2("*:**%            dir %= 360000000          // keep within the 360 degree range
                        }
  020p                  first_pass = false
  :"Z}"4*:**/10p        last_lowres_dir = dir / 22500000
  \                     last_dir = dir              // saved as second item on stack
  :!_                 } while (!stack.empty())

$                     pop()                         // this leaves the final dir on top
5+55+/                dir = (dir + 5)/10            // round down to 5 decimal places
"d":*:*+              dir += 100000000              // add a terminating digit
                      while (true) {                // convert into chars on stack
:55 + % 6 8 * +\ : _    push(dir%10+'0'); if (!dir) break
   > < 5 5 : /+ 5 5     dir /= 10
                      }

$$$                   pop() x 3                     // drop the chars we don't need
,,,                   putchar(pop()) x 3            // output first three chars
"."                   push('.')                     // add a decimal point
>:#,_@                while(c=pop()) putchar(c)     // output the remaining chars

— जेम्स होल्डरनेस
स्रोत

क्या इसका मतलब यह है कि आपको एक बड़े निश्चित बिंदु प्रकार (अधिक दशमलव स्थानों) का अनुकरण करने की आवश्यकता है? परीक्षण मामलों को दोहरी सटीकता की आवश्यकता के लिए डिज़ाइन किया गया है, जो 17 से अधिक महत्वपूर्ण आंकड़े (अधिकतम 16 दशमलव स्थान) नहीं है, और 14 दशमलव स्थान संभवतः पर्याप्त हो सकते हैं।

— ट्राइकोप्लाक्स

1

APL (Dyalog Classic) , 30 27 बाइट्स

90×(4|2÷⍨+-4×2<∘|-)/'NES'⍳⎕

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

— NGN
स्रोत

दक्षिण पूर्व द्वारा उत्तर द्वारा उत्तर

इनपुट

उत्पादन

रूपांतरण

उदाहरण

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

स्कोरिंग

पांडित्य-प्रदर्शन

जावास्क्रिप्ट (ईएस 6), 84 80 78 74 72 बाइट्स

टेस्ट स्निपेट

व्याख्या

सी # 6, 226 217 207 185 बाइट्स

PHP, 95 88 86 100 127 104 101 बाइट्स

PHP 7.1

पायथन 3, 133 113 बाइट्स

05AB1E ,48 42 37 32 बाइट्स

पायथन 3, 146 145 117 107 97 94 93 92 बाइट्स

सी, 184 बाइट्स

आर, 172 146 बाइट्स

हास्केल, 109 105 103 बाइट्स

Dyalog एपीएल , 55 45 38 बाइट्स

समाधान

व्याख्या

उपाख्यान

आम लिस्प, 347 327 बाइट्स

Befunge, 183 181 175 बाइट्स

APL (Dyalog Classic) , 30 27 बाइट्स

^{पांडित्य-प्रदर्शन}