Hintergrund

Unzählige Generationen von Kindern haben sich gefragt, wo sie landen würden, wenn sie ein Loch direkt nach unten gruben. Es stellt sich heraus, dass dies nicht überraschend ziemlich gefährlich wäre , aber trotzdem ...

Antipoden sind Punkte, die sich auf der Erdoberfläche direkt gegenüberliegen. Das bedeutet, wenn eine Linie zwischen den beiden Punkten gezogen würde, würde sie durch den Erdmittelpunkt verlaufen.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die bei gegebenem Punkt ihren Antipode findet.

Bei dieser Herausforderung werden Punkte mit dem Längen- und Breitengradsystem sowie Grad, Bogenminuten und Bogensekunden dargestellt. Um den Antipoden zu finden, tauschen Sie die Richtungen der einzelnen Ordinaten ( N <-> Sund W <-> E) und subtrahieren Sie die Längengrad-Ordinate von den 180Gradangaben.

Beispiel:
Nehmen Sie den Punkt N 50 26 23 W 4 18 29. Tauschen Sie die Richtungen, um zu geben S 50 26 23 E 4 18 29. Subtrahieren Sie die Längengrad-Ordinate von, 180 0 0um anzugeben 175 41 31, und lassen Sie die Antipoden-Koordinaten wie folgt S 50 26 23 E 175 41 31.

Regeln

Eingang

Ein Satz von Breiten- und Längenkoordinaten in einem beliebigen vernünftigen Format , wobei jede Ordinate eine Richtung, eine Anzahl von Graden, eine Anzahl von Bogenminuten und eine Anzahl von Bogensekunden enthält.

Ausgabe

Die Breitengrad-Längengrad-Koordinaten des Antipodes in einem beliebigen vernünftigen Format , wobei jede Ordinate eine Richtung, eine Anzahl von Grad, eine Anzahl von Bogenminuten und eine Anzahl von Bogensekunden enthält.

Nehmen wir an, dass jeder Teil der Koordinate eindeutig unterschieden werden kann.

Technische Daten

• Die Richtung für die Breitengrad-Ordinate ist Noder S, und die für die Längengrad-Ordinate ist Woder E.
• Alle Koordinatenwerte sind Ganzzahlen. Der Gradwert liegt zwischen 0und 90für den Breitengrad sowie zwischen 0und 180für den Längengrad. Die Bogenminuten- und Bogensekundenwerte für beide Ordinaten liegen zwischen 0und 59.
• Wenn alle Werte für eine Ordinate sind 0, ist jede Richtung akzeptabel.
• Es ist nicht erforderlich, Werte auf Null zu setzen.
• Keine Breitengrad-Ordinate wird jemals größer als 90Grad sein, und keine Längengrad-Ordinate wird jemals größer als 180Grad sein.
• Es gelten Standardlücken .

Testfälle

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

Nützliche Links

• Breiten-und Längengrad
• Antipoden
• Bogenminuten und Bogensekunden

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!

05AB1E, 37 34 Bytes

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

Erklärt

`                                      # 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

Probieren Sie es online aus

Bearbeiten: 3 Bytes dank Adnan gespeichert .

JavaScript (ES6), 88 Byte

(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]

Nimmt 8 Parameter und gibt als Ergebnis ein Array zurück. Erwartet a, einer von Noder zu sein Sund in ähnlicher eWeise einer von Woder zu sein E. Berechnungen:

• fmuss von 179 subtrahiert werden, wenn einer von beiden goder hungleich Null ist, aber von 180, wenn beide gund hNull sind (da kein Kredit vorhanden ist), wird also !(g|h)zu 179 addiert.
• gmuss null sein, wenn beide gund hnull sind g|h&&, andernfalls muss es von 59 subtrahiert werden, wenn hungleich null ist, aber 60, wenn hnull ist (da kein Kredit vorhanden ist), wird also !hzu 59 addiert.
• h muss Null sein, wenn es bereits Null war, sonst wird es einfach von 60 subtrahiert.

Eine weitere Möglichkeit zu sehen , das ist zu bemerken , dass in binärer Subtraktion durch Addition des 1s - Komplements erreicht wird , plus ein zusätzliches 1. für dieses Problem übersetzt, wir nehmen 179-f, 59-gund , 59-hund fügen Sie 1 59-h+ 1 ist 60-h, aber wenn diese 60 ist dann trägt Das gewünschte Ergebnis ist also Null, wenn hes ursprünglich Null war. Wir addieren 1 zu, 59-gwenn es einen Übertrag von gibt h, dh wenn hursprünglich Null war. Wieder müssen wir einen Übertrag berücksichtigen, der diesmal passiert, wenn beide gund hNull sind, und wir addieren 179-fin diesem Fall 1 dazu .

MATL , 51 Bytes

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

Eingabeformat:

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

Ausgabeformat:

S
50 26 23
E
175  41  31

Probieren Sie es online!

Erläuterung

'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

Schläger, 199 Bytes

(λ(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)))))

Das ist schrecklich lang. Wahrscheinlich gibt es einige Dinge , die ich tun könnte , um es weiter zu verkürzen, aber graut ich völlig fertig bin.

Nimmt ein consPaar von zwei lists: eine für den Breitengrad und eine für den Längengrad. Jede Liste hat die Richtung (als kleines Racket-Symbol) als erstes Element und folgt ihr in Grad, Bogenminuten und Bogensekunden. Ausgaben im selben Format

Racket interpretiert dieses Paar von zwei Listen als einzelne Liste mit einer anderen Liste als erstem Element. Dies ist vollkommen in Ordnung, da Sie immer noch auf Längen- und Breitengrade zugreifen können, als wären es zwei Listen in einem Paar.

Verwendung:

>    (
     (λ(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)

Was durch zukünftigen Code als '((n 43 9 9) (w 179 59 55))zwei Listen interpretiert werden kann .

Pyth, 41 45 43 35 Bytes

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

Verwendet die Basis-60-Konvertierung, um Grad und Minuten in Sekunden umzuwandeln.

E / A-Format:

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

Jedes Mal, wenn Sie eine Zeile eingeben, wird eine Zeile gedruckt . Um ein ansprechendes Format zu erhalten, können Sie entweder die CLI verwenden und die Eingabe per Pipe weiterleiten oder die Online-Pyth-Implementierung verwenden .

Im Pseudocode:

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

Python 2, 140 122 Bytes

Aktualisiert:

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])

Hierbei wird ein etwas anderer Ansatz verwendet: Festlegen der Werte zum Subtrahieren von der Länge basierend auf den Minuten und Sekunden. Wenn es 0 Minuten und Sekunden gibt, subtrahiert es 180 von den Graden, und wenn es> 0 Minuten und Sekunden gibt, subtrahiert es 179, 59 und 60 von den d, m, s.

Original:

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])

Nimmt die Eingabe als Liste f(['N', 0, 0, 0, 'E', 0, 0, 0]):, konvertiert den Längengrad in Dezimalgrad, subtrahiert von 180, konvertiert dann zurück in Grad, Minuten, Sekunden und erstellt die Liste neu, wobei die Richtungen umgekehrt werden.

Nicht golfen:

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])

Versuch es

JavaScript, 138 137 129 124 112 110

2-Byte-Verbesserung, inspiriert von Neils Code

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)]);

• Eingabe = Ausgabe = Array mit 2x (1 Großbuchstabe und 3 Int)
• in Firefox getestet

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
);

Tests

<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>

Python 3, 131 130 Bytes

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"

Formate: Winkel sind Tupel der Form (deg,min,sec), Richtungen sind der Form N. Gibt ein Vierfaches von 2 Winkeln aus, denen jeweils die Richtung folgt.

Ungolfed-Version:

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"

C #, 310 269 ​​Bytes

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;}

Die Eingabe ist eine Zeichenfolge. Sie können es auf .NetFiddle ausprobieren .

Code

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;
}

Wenn ich nicht a stringals Eingabe, sondern a nehme char, float[], char, float[], kann ich Folgendes tun:

C #, 167 166 165 163 152 148 147 139 Bytes

(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;};

Code

(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;
};

Außerdem kann ich das entfernen 3600und ฐstattdessen verwenden, um zu 164 Zeichen und 166 Bytes zu wechseln. Soll ich es benutzen?

C #, 150 Bytes

(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}";};

Code

(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}";
};

Mehr .NET! Ich delegieren alle die Logik auf die .NET struct TimeSpanund ich ab verwenden , um die Zeichenfolge Formatierung Logik. Eingabe ist char, int, int, int, char, int, int, int. Ich teile dieses, um einige Ideen zu geben. Vielleicht verbessert sich jemand besser als ich.

Java, 199 177 oder 151 oder 134 Bytes

177 Bytes Lösung, die das Ergebnis druckt

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-Byte-Lösung, die das Ergebnis als Array zurückgibt

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 Bytes, wenn wir die Lambda-Notation verwenden

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};}

C 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);}

Benötigt 8 Programmargumente, schlägt sonst fehl. Übergeben Sie Argumente wie N 50 26 23 W 4 18 29. Fahrtrichtungsanzeiger N, S, E, Wmüssen, aktiviert.

PostGIS, 123 Bytes

Das Tool-For-The-Job ist enttäuschend ausführlich, teils aufgrund von SQL-Wordiness und teils aufgrund der Notwendigkeit, auf Geometrie und zurück zu setzen:

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

Andererseits transformiert diese einzelne Funktion Punkte, Punktsammlungen oder komplexere Formen (wie die gesamte Küste Australiens und Neuseelands).

PHP, 148 Bytes

Gleicher Ansatz wie meine JavaScript-Antwort , schau dort nach einer Aufschlüsselung

• +16 Funktionsaufwand
• +17 für $Zeichen
• +12 für Klammern (unterschiedliche Operatorrangfolge)
• +4, foreachweil PHP array_mapeinen riesigen Overhead hat
• +1 für (60-$v)%60weil $v&&60-$vin PHP nach boolesch umgewandelt wird
• -8 durch Arbeiten am Original
• -4 mit chr, ordund einige Arithmetik auf den Richtungswechsel

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));}

• Funktion arbeitet am Original
• Format: Array mit 2x (1 Großbuchstabe, 3 int)

Tests

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);
}

aufgegebene Ideen

• No-Loop-Ansatz mit Carry-Flags: +5
• Schleife rückwärts mit Carry Flags: +7
• Ich könnte daraus ein Programm für PHP <5.4 machen, aber egal: -3

Befunge, 122 114 111 Bytes (110 Zeichen)

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

Eingabeformat:

N 50 26 23W 4 18 29

Beachten Sie, dass die Längengradrichtung und die Bogensekunden zusammengedrängt sein müssen

Sie können den Code testen hier