ऑस्ट्रेलिया के लिए खोदो - एंटीपोड्स

24

पृष्ठभूमि

बच्चों की अनगिनत पीढ़ियों ने सोचा है कि अगर वे सीधे नीचे की ओर एक छेद खोदेंगे तो वे कहां समाप्त होंगे। यह पता चला है कि यह, ज़ाहिर है, बल्कि खतरनाक होगा , लेकिन वैसे भी ...

एंटीपोड्स ऐसे बिंदु हैं जो पृथ्वी की सतह पर एक दूसरे के सीधे विपरीत हैं। इसका मतलब है कि यदि दो बिंदुओं के बीच एक रेखा खींची जाती है, तो यह पृथ्वी के केंद्र से होकर गुजरेगी।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें, जो एक बिंदु दिया गया है, इसका एंटीपोड ढूंढता है।

इस चुनौती में, देशांतर-अक्षांश प्रणाली और डिग्री, चाप मिनट और चाप सेकंड का उपयोग करके बिंदुओं का प्रतिनिधित्व किया जाता है। एंटीपोड को खोजने के लिए, प्रत्येक ऑर्डिनेट ( N <-> Sऔर W <-> E) की दिशाओं को स्वैप करें और 180डिग्री से लॉन्गिट्यूड ऑर्डिनेट को घटाएं ।

उदाहरण:
बिंदु को लें N 50 26 23 W 4 18 29। निर्देश देने के लिए स्वैप करें S 50 26 23 E 4 18 29। एंटीपोड निर्देशांक के रूप में छोड़ने के 180 0 0लिए देने के लिए तालमेल से 175 41 31समायोजित करें S 50 26 23 E 175 41 31।

नियम

इनपुट

अक्षांश-देशांतर का एक सेट किसी भी उचित प्रारूप में निर्देशांक करता है , जहां प्रत्येक निर्देशांक में एक दिशा, कई डिग्री, कई आर्क मिनट और कई चाप सेकंड होते हैं।

उत्पादन

एंटीटोड के अक्षांश-देशांतर निर्देशांक, किसी भी उचित प्रारूप में , जहां प्रत्येक ऑर्डिनेट में एक दिशा, कई डिग्री, कई आर्क मिनट और कई आर्क सेकंड होते हैं।

इसका उचित अर्थ निकालें कि समन्वय के प्रत्येक भाग को स्पष्ट रूप से प्रतिष्ठित किया जा सकता है।

चश्मा

  • अक्षांश के लिए दिशा निर्देश है Nया S, और देशांतर के लिए निर्देशांक है Wया E।
  • सभी समन्वय मूल्य पूर्णांक हैं। डिग्री मूल्य के बीच हो जाएगा 0और 90अक्षांश के लिए, और के बीच 0और 180देशांतर के लिए। दोनों दिशाओं के लिए चाप मिनट और चाप दूसरा मान के बीच 0और होगा 59।
  • यदि 0किसी निर्देश के लिए सभी मान हैं , तो दोनों दिशाएँ स्वीकार्य हैं।
  • किसी भी मान को शून्य-पैड करने की आवश्यकता नहीं है।
  • कोई भी अक्षांश ऑर्डिनेट कभी भी 90डिग्री से बड़ा नहीं होगा, और कोई भी लॉन्गिट्यूड ऑर्डिनेट कभी भी 180डिग्री से बड़ा नहीं होगा ।
  • मानक खामियां लागू होती हैं।

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

N 50 26 23 W 4 18 29 -> S 50 26 23 E 175 41 31

S 43 9 9 E 0 0 5     -> N 43 9 9 W 179 59 55

N 0 0 0 E 0 0 0      -> S/N 0 0 0 W/E 180 0 0 (either direction fine in each case)

S 1 2 3 W 4 5 6      -> N 1 2 3 E 175 54 54

S 9 21 43 W 150 7 59 -> N 9 21 43 E 29 52 1

S 27 40 2 W 23 0 0   -> N 27 40 2 E 157 0 0

N 0 58 37 W 37 0 0   -> S 0 58 37 E 143 0 0

उपयोगी कड़ियाँ

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

code-golf 
— TheBikingViking
स्रोत
क्या यह एक उचित प्रारूप है? चार इनपुट: 3 नंबर की सरणी, चार नंबर की सरणी; नई कहानियों से अलग
— लुइस मेंडू
@LuisMendo जब तक मैं आपको गलत समझ रहा हूं, मैं केवल तीन इनपुट देख सकता हूं; मुझे लगता है कि आप एक अतिरिक्त आकर्षण चाहते हैं? मैं कहूंगा कि यह एक उचित प्रारूप है। उचित रूप से, मेरा अनिवार्य रूप से मतलब है कि समन्वय के प्रत्येक भाग को स्पष्ट रूप से प्रतिष्ठित किया जा सकता है।
— बाइकिंग बाइक
हां, मैं पहला चरखा भूल गया। धन्यवाद!
— लुइस मेंडू
3
"बल्कि खतरनाक"? मेट, असली खतरा एक बार तुम यहाँ मिल रहा है ।
— एंड्रयू ग्रिम
1
@busukxuan जल्द जवाब नहीं देने के लिए माफी। मैं कहूँगा कि उन स्वरूपों के दोनों के बाद से कल्पना की आवश्यकता है, उचित नहीं हैं N, S, E, या Wएक दिशा के रूप में है, जबकि अनावश्यक 0जो मूल्य के रूप में प्रस्तुत किया जाने अस्पष्टता जो तालमेल के घटक प्रतिनिधित्व करता है।
— TheBikingViking

जवाबों:

1

05AB1E, 37 34 बाइट्स

`60©3L<Rm*O3°648*s-®‰`s®‰s‚˜)'€Ã‡

व्याख्या की

`                                      # split input to 4 lines with longitude on top
 60©3L<Rm*O                            # convert longitude to seconds
            3°648*                     # longitude 180 0 0 in seconds
                  s-                   # subtract our longitude from this
                    ®‰`                # get seconds part
                       s®‰             # get minute and degrees part
                          s‚˜)         # join to list
                              '€Ã‡    # translate directions

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

संपादित करें: अदनान के लिए 3 बाइट्स सहेजे गए ।

— Emigna
स्रोत
आप सेक कर सकते हैं "NEWS"करने के लिए ‘€Ã‘या यहां तक कि '€Ãछोटे अक्षरों की अनुमति है।
— अदनान
@ अदनान: अच्छा! क्योंकि पहले से ही तार इतना छोटा था, क्योंकि संपीड़ित करने के बारे में नहीं सोचा था।
— इलिग्ना
6

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

(a,b,c,d,e,f,g,h)=>[a<'S'?'S':'N',b,c,d,e<'W'?'W':'E',!(g|h)+179-f,g|h&&!h+59-g,h&&60-h]

परिणाम के रूप में 8 पैरामीटर लेता है और एक सरणी देता है। उम्मीद aमें से एक है Nया Sऔर इसी तरह eसे एक होने का Wया E। गणना:

  • fजरूरतों को 179 से घटाया करने के लिए किया जा यदि या तो gया hअशून्य लेकिन 180 दोनों अगर है gऔर hशून्य (कोई उधार न होने के कारण), इस प्रकार हैं !(g|h)179 में जोड़ा जाता है।
  • gजरूरतों को शून्य दोनों अगर होना करने के लिए gऔर hशून्य है, इस प्रकार हैं g|h&&, अन्यथा यह 59 से घटाया जा सकता है अगर जरूरत है hअशून्य है, लेकिन 60 यदि hशून्य है (क्योंकि वहाँ कोई उधार है), इस प्रकार !h59 में जोड़ा जाता है।
  • h शून्य होने की आवश्यकता है यदि यह पहले से ही शून्य था, अन्यथा इसे केवल 60 से घटाया जाता है।

इस पर ध्यान देने का एक और तरीका यह है कि बाइनरी में घटाना 1 एस पूरक के अतिरिक्त जोड़कर हासिल किया जाता है। 1. इस समस्या के लिए अनुवाद, हम लेते हैं 179-f, 59-gऔर 59-h1. 59-h+ 1 जोड़ते हैं 60-h, लेकिन अगर यह 60 है, तो यह होता है। , तो वांछित परिणाम शून्य है यदि hमूल रूप से शून्य था। 59-gअगर वहाँ से मूल रूप से शून्य था h, तो हम 1 जोड़ते हैं h। फिर हम एक कैरी के लिए अनुमति देने के लिए, जो इस समय होता है अगर दोनों gऔर hशून्य हैं, और हम में 1 जोड़ 179-fइस मामले में।

— नील
स्रोत
6

MATL , 51 बाइट्स

'NS'tPXEii'WE'tPXE648e3i60:qXJZA-JYAtn3-?2:&)wJZAwh

इनपुट प्रारूप:

'N'
[50 26 23]
'W'
[4 18 29]

आउटपुट स्वरूप:

S
50 26 23
E
175  41  31

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

व्याख्या

'NS'tPXE     % Take input (string) implicitly. Exchange 'N' and 'S'
i            % Take input (array)
i'WE'tPXE    % Take input (string). Exchange 'W' and 'E'
648e3        % Push 648000
i            % Take input (array)
60:qXJ       % Push [0 1 ... 59]. Copy into clipboard J
ZA           % Convert second input array from base 60 to decimal
-            % Subtract
JYA          % Convert to base 60
tn3-?        % If length exceeds 3
  2:&)       %   Split into first two elements and then the rest
  w          %   Swap
  JZA        %   Convert from base 60 to decimal
  wh         %   Swap, concatenate
— लुइस मेंडो
स्रोत
दूसरी से अंतिम पंक्ति में आपके स्पष्टीकरण में एक टाइपो है bnase:।
— TheBikingViking
1
@BikingViking धन्यवाद! सही किया
— लुइस मेंडू जूल
4

रैकेट, 199 बाइट्स

(λ(l)(cons(cons(if(eq?(caar l)'n)'s'n)(cdar l))(cons(if(eq?(cadr l)'e)'w'e)(list (- 180(+(caddr l)(sgn(foldl + 0(cdddr l)))))(modulo(- 60(+(fourth l)(sgn(fifth l))))60)(modulo(- 60(fifth l))60)))))

वह बहुत लंबा है। शायद कुछ चीजें मैं इसे आगे छोटा करने के लिए कर सकता है, लेकिन shudders मैं पूरी तरह से किया हूँ।

consदो की एक जोड़ी लेता है lists: अक्षांश के लिए एक और देशांतर के लिए एक। प्रत्येक सूची में इसके पहले आइटम के रूप में दिशा (एक निचले रैकेट प्रतीक के रूप में) और इसके बाद डिग्री, चाप-मिनट और आर्क-सेकंड हैं। एक ही प्रारूप में आउटपुट

रैकेट दो सूचियों की इस जोड़ी को एक एकल सूची के रूप में एक अन्य सूची के साथ इसके पहले तत्व के रूप में व्याख्या करेगा। यह पूरी तरह से ठीक है, क्योंकि आप अभी भी अक्षांश और देशांतर दोनों का उपयोग कर सकते हैं जैसे कि वे एक जोड़ी में दो सूचियां थीं।

उपयोग:

>    (
     (λ(l)(cons(cons(if(eq?(caar l)'n)'s'n)(cdar l))(cons(if(eq?(cadr l)'e)'w'e)(list (- 180(+(caddr l)(sgn(foldl + 0(cdddr l)))))(modulo(- 60(+(fourth l)(sgn(fifth l))))60)(modulo(- 60(fifth l))60)))))
     (cons (list 's 43 9 9) (list 'e 0 0 5)))
'((n 43 9 9) w 179 59 55)

जिसकी व्याख्या भविष्य के कोड के रूप में '((n 43 9 9) (w 179 59 55)), दो सूचियों से की जा सकती है।

— स्टीवन एच।
स्रोत
4

पायथ, 41 45 43 35 बाइट्स

K60-"NS"ww-"EW"wA.D-*3^K3iEKK+.DGKH

डिग्री और मिनटों को सेकंड में बदलने के लिए बेस -60 रूपांतरण का उपयोग करता है।

I / O प्रारूप:

N
[1,2,3]
E
[4,5,6]

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

छद्मकोश में:

K60                                              K = 60
   -"NS"w                                        "NS".remove(input())
         w                                       print(input())
          -"EW"w                                 "EW".remove(input())
                A.D                              G,H = divmod(
                   -*3^K3                          3*K**3 -
                         iEK                         baseToDec(input(),K)),
                            K                      K)
                             +.DGKH              divmod(G,K)+H
— busukxuan
स्रोत
@LuisMendo आपकी ही तरह, लेकिन कॉमा ने सूचियों को अलग कर दिया, और कोई उद्धरण नहीं
— बसुकक्सुआन
4

पायथन 2, 140 122 बाइट्स

अपडेट किया गया:

def f(c):x=([180,0,0],[179,59,60])[1<sum(c[6:8])];print['NS'['N'in c]]+c[1:4]+['EW'['E'in c]]+map(lambda x,y:x-y,x,c[5:8])

यह कुछ अलग दृष्टिकोण का उपयोग करता है: मानों को मिनट और सेकंड के आधार पर देशांतर से घटाना। यदि 0 मिनट और सेकंड हैं, तो यह 180 डिग्री से घटाता है, और अगर> 0 मिनट और सेकंड हैं, तो यह क्रमशः d, m, s से 179, 59 और 60 घटाता है।

मूल:

def f(c):v=divmod;m,s=v((180-(c[5]+c[6]/60.+c[7]/3600.))*3600,60);d,m=v(m,60);print['NS'['N'in c]]+c[1:4]+['EW'['E'in c]]+map(round,[d,m,s])

एक सूची के रूप में इनपुट लेता है:, f(['N', 0, 0, 0, 'E', 0, 0, 0])देशांतर को दशमलव डिग्री में परिवर्तित करता है, 180 से घटाता है, फिर डिग्री, मिनट, सेकंड में परिवर्तित करता है और सूची को फिर से बनाता है, प्रक्रिया में दिशाओं को प्रवाहित करता है।

संयुक्त राष्ट्र के golfed:

def f(c):
    minutes,seconds=divmod((180-(c[5]+c[6]/60.+c[7]/3600.))*3600,60)
    degrees,minutes=divmod(minutes,60)
    print ['NS'['N'in c]]+c[1:4]+['EW'['E'in c]]+map(round,[degrees,minutes,seconds])

कोशिश करो

— atlasologist
स्रोत
3

जावास्क्रिप्ट, 138 137 129 124 112 110

@ बाइल कोड से प्रेरित 2 बाइट्स सुधार

f=a=>a.map((v,i,a)=>i%4?i>6?v&&60-v:i>5?(59-v+!a[7])%60:i>4?179-v+!(a[7]|a[6]):v:'NEWS'[3-'NEWS'.indexOf(v)]);
  • इनपुट = आउटपुट = सरणी 2x (1 अपरकेस चार और 3 इंट) युक्त
  • फ़ायरफ़ॉक्स में परीक्षण किया गया

ungolfed

f=a=>a.map((v,i,a)=>
i%4?
    i>6?v&&60-v              // 7: invert seconds - old: (60-v)%60
    :i>5?(59-v+!a[7])%60     // 6: invert minutes, increase if seconds are 0
    :i>4?179-v+!(a[7]|a[6])  // 5: invert degrees, increase if seconds and minutes are 0
    :v                       // 1,2,3: unchanged
:'NEWS'[3-'NEWS'.indexOf(v)] // 0,4: swap directions
);

परीक्षण

<table id=out border=1><tr><th>in</th><th>out<th>expected</th><th>ok?</th></tr></table>
<script>
addR=(r,s)=>{var d=document.createElement('td');d.appendChild(document.createTextNode(s));r.appendChild(d)}
test=(x,e,f)=>{var y,r=document.createElement('tr');addR(r,x);addR(r,y=('function'==typeof f)?f(x):f);addR(r,e);addR(r,e.toString()==y.toString()?'Y':'N');document.getElementById('out').appendChild(r)}

samples=[
'N',50,26,23,'W',4,18,29,   'S',50,26,23,'E',175,41,31,
'S',43,9,9,'E',0,0,5,       'N',43,9,9,'W',179,59,55,
'N',0,0,0,'E',0,0,0,        'S',0,0,0,'W',180,0,0,
'S',1,2,3,'W',4,5,6,        'N',1,2,3,'E',175,54,54,
'S',9,21,43,'W',150,7,59,   'N',9,21,43,'E',29,52,1,
'S',27,40,2,'W',23,0,0,     'N',27,40,2,'E',157,0,0,
'N',0,58,37,'W',37,0,0,     'S',0,58,37,'E',143,0,0,
];
while (samples.length)
{
    x=samples.splice(0,8);
    e=samples.splice(0,8);
    test(x,e,h);
    test(e,x,h);
}
</script>
— टाइटस
स्रोत
आह, मैं अभी देख रहा हूं @ नील का भी यही विचार था, लेकिन कुछ छोटे पैराट्राइकिंग
— टाइटस
2

पायथन 3, 131 130 बाइट्स

def f(w,x,y,z):S=60;d=divmod;a,b,c=y;l,m=d(648e3-c-S*b-S*S*a,S);return w,"N" if x=="S" else "S",d(l,S)+(m,),"E" if z=="W" else "W"

स्वरूप: कोण रूप के रूप हैं (deg,min,sec), दिशाएं रूप की हैं N। 2 कोणों का एक चौगुना आउटपुट करता है, प्रत्येक इसकी दिशा द्वारा पीछा किया जाता है।

Ungolfed संस्करण:

def f(latitude,NS,longitude,EW):
    degree,minute,second=longitude
    minute,second=divmod(648000-second-60*minute-60*60*degree,60)
    return latitude, "N" if NS=="S" else "S", divmod(minute,60)+(second,), "E" if EW=="W" else "W"
— busukxuan
स्रोत
1
आप ऐसा करके 120 बाइट्स को यह नीचे प्राप्त कर सकते हैं def f(w,x,y,z):S=60;d=divmod;a,b,c=y;l,m=d(648e3-c-S*b-S*S*a,S);return w,["S","N"][x=="S"],d(l,S)+(m,),["W","E"][z=="W"]तथ्य यह है कि का उपयोग करके यह काम करता है Trueऔर Falseके रूप में व्याख्या की जा सकती है 1और 0है, और इसलिए a if b else cके बराबर है [c, a][b]। एक साइड नोट पर, मुझे लगता है कि आपके मूल कोड में एक टाइपो है; होना x=="W"चाहिए z=="W"?
— बाइकिंगवीकलिंग
2

सी #, 310 269 ​​बाइट्स

float[]t(string[]a,int n)=>a.Skip(n).Take(3).Select(float.Parse).ToArray();string A(string i){var s=i.Split(' ');var w=t(s,5);float a=180-(w[0]+w[1]/60+w[2]/3600),b=a%1*60;return(s[0][0]>82?"N":"S")+$" {string.Join(" ",t(s,1))} {(s[4][0]<70?'W':'E')} {a} {b} "+b%1*60;}

इनपुट एक स्ट्रिंग है। आप इसे .NetFiddle पर आज़मा सकते हैं ।

कोड

float[]t(string[]a,int n)=>a.Skip(n).Take(3).Select(float.Parse).ToArray();
string A(string i) {
    var s=i.Split(' ');var w=t(s,5);float a=180-(w[0]+w[1]/60+w[2]/3600),b=a%1*60;
    return (s[0][0]>82?"N":"S")
        +$" {string.Join(" ",t(s,1))} {(s[4][0]<70?'W':'E')} {a} {b} "+b%1*60;
}

अगर मैं एक stringइनपुट के रूप में नहीं लेता char, float[], char, float[]हूं, लेकिन मैं कर सकता हूं:

सी #, 167 166 165 163 152 148 147 139 बाइट्स

(s,n,e,w)=>{float a=180-(w[0]+w[1]/60+w[2]/3600),b=a%1*60;return(s>82?"N":"S")+$" {string.Join(" ",n)} {(e<70?'W':'E')} {a} {b} "+b%1*60;};

कोड

(s,n,e,w) => {
    float a=180-(w[0]+w[1]/60+w[2]/3600),b=a%1*60;
    return(s>82?"N":"S")+$" {string.Join(" ",n)} {(e<70?'W':'E')} {a} {b} "+b%1*60;
};

इसके अलावा मैं 164 अक्षरों और 166 बाइट्स पर जाने के बजाय इसे हटा सकता हूं 3600और उपयोग कर सकता हूं ฐ। क्या मुझे इसका उपयोग करना चाहिए?

सी #, 150 बाइट्स

(s,n,m,p,e,w,x,y)=>{var t=new TimeSpan(180,0,0)-new TimeSpan(w,x,y);return(s>82?"N":"S")+$" {n} {m} {p} {(e<70?'W':'E')} {t.TotalHours} {t:%m\\ s}";};

कोड

(s,n,m,p,e,w,x,y) => {
    var z=new TimeSpan(180,0,0)-new TimeSpan(w,x,y);
     return(s>82?"N":"S")+$" {n} {m} {p} {(e<70?'W':'E')} {z.TotalHours} {z:%m\\ s}";
};

एक और .NET तरीका! मैं .NET को सभी तर्क सौंपताstruct TimeSpan हूं और मैं स्ट्रिंग स्वरूपण तर्क का उपयोग करता हूं । इनपुट है । मैं कुछ विचार देने के लिए इसे साझा करता हूं। शायद कोई मुझसे बेहतर तरीके से सुधार करेगा।char, int, int, int, char, int, int, int

— aloisdg का कहना है कि मोनिका को बहाल करें
स्रोत
यह दुर्भाग्य से क्रिया है।
— स्टीवन एच।
@Fawful मैं विभिन्न तर्कों के साथ एक और संस्करण पोस्ट करता हूं। कम क्रिया नहीं है? मैं अभी भी छुटकारा नहीं पा सकता हूं string.Join()...
— अलिस्दग का कहना है कि
ध्यान दें कि यह C # 6.0 है
— Yytsi
@TuukkaX चूंकि यह C # का सबसे अंतिम संस्करण है, इसलिए मैंने इसे निर्दिष्ट नहीं किया। अगर मैं कुछ अन रिलीज़ फीचर जैसे C # 7 फीचर का उपयोग करूंगा।
— aloisdg का कहना है कि मोनिका
1
ठीक है, मैं नहीं है को देखने के लिए एक return, मैं इसे अपने आप को जोड़ने के लिए ... अपने परीक्षण का उपयोग किया था a('N', new float[] { 50, 26, 23 }, 'W', new float[] { 4, 18, 29 })मैं S 50 26 23 E 175.6919 41.51642 30.98511- आप इस एक पास पर विचार करेंगे?
— onedaywhen
0

जावा, 199 177 या 151 या 134 बाइट्स

177 बाइट्स समाधान जिसके परिणामस्वरूप प्रिंट होता है

void t(int...a){int i=648000-(a[5]*3600+a[6]*60+a[7]);System.out.println(a[0]=='N'?"S":"N"+" "+a[1]+" "+a[2]+" "+a[3]+" "+(a[4]=='E'?"W":"E")+" "+i/3600+" "+i/60%60+" "+i%60);}

151 बाइट्स समाधान जो सरणी के रूप में परिणाम देता है

Object[]y(int...a){int i=648000-(a[5]*3600+a[6]*60+a[7]);return new Object[]{a[0]=='N'?"S":"N",a[1],a[2],a[3],a[4]=='E'?"W":"E",i/3600,i/60%60,i%60};}

134 बाइट्स अगर हमने लैम्बडा नोटेशन का उपयोग किया है

a->{int i=648000-a[5]*3600-a[6]*60-a[7];return new Object[]{a[0]=='N'?"S":"N",a[1],a[2],a[3],a[4]=='E'?"W":"E",i/3600,i/60%60,i%60};}
— user902383
स्रोत
0

सी, 188

main(int c,char**v){int n=*v[1]==78?83:78,e=*v[5]==69?87:69,b=648000-(atoi(v[6])*3600+atoi(v[7])*60+atoi(v[8]));printf("%c %s %s %s %c %d %d %d\n",n,v[2],v[3],v[4],e,b/3600,b/60%60,b%60);}

8 प्रोग्राम तर्क की आवश्यकता है, अन्यथा विफल हो जाएगी। जैसे तर्क पास करो N 50 26 23 W 4 18 29। दिशा संकेतक N, S, E, W, कैपिटल नहीं किया जाना चाहिए।

— owacoder
स्रोत
0

PostGIS, 123 बाइट्स

टूल-फॉर-द-जॉब निराशाजनक रूप से वर्बोज़ है, आंशिक रूप से एसक्यूएल वर्डिनेस के कारण और आंशिक रूप से ज्यामिति और बैक में डालने की आवश्यकता के कारण:

CREATE FUNCTION f(p geography)
RETURNS geography
AS 'SELECT ST_Affine(p::geometry,1,0,0,-1,180,0)::geography' LANGUAGE sql;

दूसरी ओर, यह एकल कार्य बिंदुओं, बिंदुओं के संग्रह या अधिक जटिल आकृतियों (जैसे कि ऑस्ट्रेलिया और न्यूजीलैंड के पूरे समुद्र तट) को बदल देगा।

— टोबी स्पाईट
स्रोत
0

PHP, 148 बाइट्स

मेरे जावास्क्रिप्ट जवाब के रूप में एक ही दृष्टिकोण , एक टूटने के लिए वहाँ देखो

  • +16 फंक्शन ओवरहेड
  • +17 $संकेतों के लिए
  • परांठे के लिए +12 (विभिन्न ऑपरेटर पूर्वता)
  • +4 foreachक्योंकि PHP4s array_mapका एक बहुत बड़ा ओवरहेड है
  • +1 (60-$v)%60क्योंकि $v&&60-$vPHP में बूलियन के लिए जाती है
  • -8 मूल पर काम करके
  • -4 का उपयोग करके chr, ordऔर दिशा स्वैप पर कुछ अंकगणित

function f(&$a){foreach($a as$i=>$v)$a[$i]=$i%4?($i>6?(60-$v)%60:($i>5?(59-$v+!$a[7])%60:($i>4?179-$v+!($a[7]|$a[6]):$v))):chr(($i?156:161)-ord($v));}
  • समारोह मूल पर काम करता है
  • प्रारूप: 2x के साथ सरणी (1 अपरकेस चार, 3 इंट)

परीक्षण

function out($a){if(!is_array($a))return$a;$r=[];foreach($a as$v)$r[]=out($v);return'['.join(',',$r).']';}
function cmp($a,$b){if(is_numeric($a)&&is_numeric($b))return 1e-2<abs($a-$b);if(is_array($a)&&is_array($b)&&count($a)==count($b)){foreach($a as $v){$w = array_shift($b);if(cmp($v,$w))return true;}return false;}return strcmp($a,$b);}
$samples=[
N,50,26,23,W,4,18,29,   S,50,26,23,E,175,41,31,
S,43,9,9,E,0,0,5,       N,43,9,9,W,179,59,55,
N,0,0,0,E,0,0,0,        S,0,0,0,W,180,0,0,
S,1,2,3,W,4,5,6,        N,1,2,3,E,175,54,54,
S,9,21,43,W,150,7,59,   N,9,21,43,E,29,52,1,
S,27,40,2,W,23,0,0,     N,27,40,2,E,157,0,0,
N,0,58,37,W,37,0,0,     S,0,58,37,E,143,0,0,
];
while ($samples)
{
    $xx=$x=array_splice($samples,0,8);
    $ee=$e=array_splice($samples,0,8);
    func($x); test($xx,$ee,$x);
    func($e); test($ee,$xx,$e);
}

विचारों को त्याग दिया

  • कैरी फ्लैग के साथ लूप अप्रोच नहीं: +5
  • लूप पीछे की ओर झंडे के साथ: +7
  • मैं इसे PHP <5.4 के लिए एक कार्यक्रम में बदल सकता हूं, लेकिन कभी भी मन नहीं: -3
— टाइटस
स्रोत
0

Befunge, 122 114 111 बाइट्स (110 अक्षर)

~"N"-v
 v"N"_"S"
v>,&.&.&.~"W"-
_"E"v"W"
+:v >,&"´"\-&"Z"*&
v\_\.00..@.-\"<".-1\ <
>1-.:"Z"/"<"\-\"Z"%:#^_\..@

इनपुट प्रारूप:

N 50 26 23W 4 18 29

देशांतर दिशा और चाप सेकंड को एक साथ huddled होना चाहिए

आप यहां कोड का परीक्षण कर सकते हैं

— Maliafo
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.