tło

Niezliczone pokolenia dzieci zastanawiały się, gdzie by się skończyły, gdyby wykopały dziurę bezpośrednio w dół. Okazuje się, że byłoby to, co nie dziwi, raczej niebezpieczne , ale i tak ...

Antypody to punkty, które są naprzeciw siebie na powierzchni Ziemi. Oznacza to, że gdyby linia została narysowana między dwoma punktami, przeszedłaby przez środek Ziemi.

Wyzwanie

Napisz program lub funkcję, która, biorąc pod uwagę punkt, znajdzie swój antypod.

W tym wyzwaniu punkty są reprezentowane przy użyciu systemu długości i szerokości geograficznej oraz stopni, minut łuku i sekund łuku. Aby znaleźć antypod, zamień kierunki każdej rzędnej ( N <-> Si W <-> E) i odejmij rzędną długości geograficznej od 180stopni.

Przykład:
Weź punkt N 50 26 23 W 4 18 29. Zamień wskazówki, aby podać S 50 26 23 E 4 18 29. Odejmij rzędną długości geograficznej od, 180 0 0aby dać 175 41 31, pozostawiając współrzędne antypody jako S 50 26 23 E 175 41 31.

Zasady

Wkład

Zestaw współrzędnych szerokości i długości geograficznej, w dowolnym rozsądnym formacie , w którym każda rzędna zawiera kierunek, liczbę stopni, liczbę minut łuku i liczbę sekund łuku.

Wydajność

Współrzędne szerokości i długości geograficznej antypodu, w dowolnym rozsądnym formacie , gdzie każda rzędna zawiera kierunek, liczbę stopni, liczbę minut łuku i liczbę sekund łuku.

Rozumiem, że każdą część współrzędnych można jednoznacznie rozróżnić.

Okular

• Kierunek dla rzędnej szerokości geograficznej to Nlub S, a dla rzędnej długości geograficznej jest Wlub E.
• Wszystkie wartości współrzędnych są liczbami całkowitymi. Wartość stopnia będzie pomiędzy 0i 90dla szerokości geograficznej oraz pomiędzy 0i 180dla długości geograficznej. Wartości minut łuku i sekund łuku dla obu rzędnych będą pomiędzy 0i 59.
• Jeśli wszystkie wartości dla rzędnej są 0, dowolny kierunek jest akceptowalny.
• Nie ma potrzeby zerowania żadnych wartości.
• Żadna rzędna szerokości geograficznej nigdy nie będzie większa niż 90stopnie i żadna rzędna długości geograficznej nigdy nie będzie większa niż 180stopnie.
• Obowiązują standardowe luki .

Przypadki testowe

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

Przydatne linki

• Szerokość i długość geograficzna
• Antypody
• Łuk minuty i sekundy łuku

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach!

05AB1E, 37 34 bajtów

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

Wyjaśnił

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

Wypróbuj online

Edycja: Zapisano 3 bajty dzięki Adnan .

JavaScript (ES6), 88 bajtów

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

Pobiera 8 parametrów i zwraca tablicę jako wynik. Oczekuje asię jednym Nlub Spodobnie ebyć jedną Wlub E. Obliczenia:

• fmusi być odjęta od 179 jeżeli jeden glub hjest różna od zera, lecz 180, gdy oba gi hmają wartość zero (ponieważ nie ma pożyczać), co !(g|h)dodaje się do 179.
• gmusi być zerowy, gdy oba gi hmają wartość zero, co g|h&&, w przeciwnym razie musi być odjęta od 59, jeśli hnie jest zerem, ale 60, hjest równa zero (ponieważ nie ma pożyczać), co !hdodaje się do 59.
• h musi wynosić zero, jeśli było już zero, w przeciwnym razie jest po prostu odejmowane od 60.

Innym sposobem spojrzenia na to zauważyć, że odjęcie binarnie uzyskuje się przez dodanie 1s uzupełnienie plus dodatkowe 1. przetłumaczony na ten problem, bierzemy 179-f, 59-ga 59-hi dodać 1 59-h+ 1 60-h, ale jeśli jest to 60 to niesie , więc pożądany wynik to zero, jeśli hpierwotnie było zero. Dodajemy 1, 59-gjeśli występuje przeniesienie z h, tzn. Jeśli hpierwotnie było zero. Ponownie musimy umożliwić Carry, który tym razem dzieje się wtedy, gdy oba gi hsą zerowe, a dodamy 1 do 179-fniniejszej sprawy.

MATL , 51 bajtów

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

Format wejściowy:

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

Format wyjściowy:

S
50 26 23
E
175  41  31

Wypróbuj online!

Wyjaśnienie

'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

Rakieta, 199 bajtów

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

To jest okropnie długie. Prawdopodobnie jest kilka rzeczy, które mógłbym zrobić, aby to jeszcze bardziej skrócić, ale drżę , jestem całkowicie skończony.

Pobiera consdwa lists: jeden dla szerokości i jeden dla długości. Każda lista ma kierunek (jako mały symbol rakiety) jako swój pierwszy element i następujące po nim stopnie, minuty i sekundy łukowe. Wyjścia w tym samym formacie

Rakieta zinterpretuje tę parę dwóch list jako pojedynczą listę z inną listą jako pierwszym elementem. Jest to całkowicie w porządku, ponieważ nadal możesz uzyskać dostęp do szerokości i długości geograficznej, jakby były dwiema listami w parze.

Stosowanie:

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

Który może być interpretowany przez przyszły kod jako '((n 43 9 9) (w 179 59 55))dwie listy.

Pyth, 41 45 43 35 bajtów

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

Wykorzystuje konwersję base-60, aby zamienić stopnie i minuty w sekundy.

Format we / wy:

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

Drukuje linię za każdym razem, gdy ją wprowadzasz, więc aby mieć dobrze wyglądający format, możesz albo użyć interfejsu CLI i potokować dane wejściowe, albo, wygodniej, użyć internetowej implementacji Pyth .

W pseudokodzie:

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 bajtów

Zaktualizowano:

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

Stosuje to nieco inne podejście: ustawienie wartości odejmowania od długości geograficznej na podstawie minut i sekund. Jeśli jest 0 minut i sekund, odejmuje 180 stopni od stopni, a jeśli jest> 0 minut i sekund, odejmuje odpowiednio 179, 59 i 60 od d, m, s.

Oryginalny:

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

Pobiera dane wejściowe jako listę: f(['N', 0, 0, 0, 'E', 0, 0, 0])konwertuje długość geograficzną na stopnie dziesiętne, odejmuje od 180, a następnie konwertuje z powrotem na stopnie, minuty, sekundy i ponownie konstruuje listę, odwracając kierunki w tym procesie.

Bez golfa:

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

Spróbuj

JavaScript, 138 137 129 124 112 110

2 bajty poprawy zainspirowane kodem @ Neila

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

• input = output = tablica zawierająca 2x (1 wielkie litery i 3 int)
• przetestowane w Firefoksie

bez golfa

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

testy

<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 bajtów

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"

Formaty: kąty są krotkami formy (deg,min,sec), kierunki są formą N. Wysyła czterokrotnie 2 kąty, z których każdy ma swój kierunek.

Wersja bez golfa:

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 ​​bajtów

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

Dane wejściowe to jeden ciąg. Możesz spróbować na .NetFiddle .

Kod

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

Jeśli nie wezmę stringjako danych wejściowych, ale a char, float[], char, float[], mogę:

C #, 167 166 165 163 152 148 147 147 139 bajtów

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

Kod

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

Mogę również usunąć 3600i użyć ฐzamiast tego, aby przejść do 164 znaków i 166 bajtów. Czy powinienem tego użyć?

C #, 150 bajtów

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

Kod

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

Bardziej .NET sposób! I przekazać całą logikę do .NET struct TimeSpani ab użyć ciąg formatowanie logiki. Dane wejściowe to char, int, int, int, char, int, int, int. Podzielam się tym, aby podać kilka pomysłów. Może ktoś poprawi się lepiej niż ja.

Java, 199 177 lub 151 lub 134 bajtów

177 bajtów rozwiązanie, które drukuje wynik

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 Bajtów rozwiązanie, które zwraca wynik jako tablicę

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 bajtów, jeśli użyliśmy notacji lambda

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

Wymaga 8 argumentów programu, w przeciwnym razie zawiedzie. Przekaż argumenty jak N 50 26 23 W 4 18 29. Kierunkowskazy N, S, E, W, muszą być aktywowane.

PostGIS, 123 bajty

Tool-For-The-Job jest rozczarowująco gadatliwy, częściowo z powodu słownictwa SQL, a częściowo z powodu potrzeby rzutowania na geometrię i odwrotnie:

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

Z drugiej strony ta pojedyncza funkcja przekształci punkty, zbiory punktów lub bardziej złożone kształty (takie jak cała linia brzegowa Australii i Nowej Zelandii).

PHP, 148 bajtów

tak samo jak moja odpowiedź na JavaScript , poszukaj tam podziału

• Narzut +16 funkcji
• +17 za $znaki
• +12 dla nawiasów (inny priorytet operatora)
• +4, foreachponieważ PHP array_mapma ogromne koszty ogólne
• +1 za, (60-$v)%60ponieważ $v&&60-$vrzutuje na boolean w PHP
• -8 poprzez pracę na oryginale
• -4 przy użyciu chr, orda niektóre operacje arytmetyczne na zamiany kierunku

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

• funkcja działa na oryginale
• format: tablica z 2x (1 wielka litera, 3 int)

testy

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

porzucone pomysły

• podejście bez pętli z flagami przenoszenia: +5
• pętla do tyłu z flagami przenoszenia: +7
• Mógłbym to zmienić w program dla PHP <5.4, ale nieważne: -3

Befunge, 122 114 111 bajtów (110 znaków)

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

Format wejściowy:

N 50 26 23W 4 18 29

Zwróć uwagę na kierunek długości geograficznej i sekundy łuku muszą być skulone

Możesz przetestować kod tutaj