Étant donné la latitude / longitude de deux points sur la Lune (lat1, lon1)et (lat2, lon2), calculez la distance entre les deux points en kilomètres, en utilisant n'importe quelle formule qui donne le même résultat que la formule haversine.

Contribution

• Quatre valeurs entières lat1, lon1, lat2, lon2en degrés (angle) ou
• quatre valeurs décimales ϕ1, λ1, ϕ2, λ2en radians.

Production

Distance en kilomètres entre les deux points (décimale avec n'importe quelle précision ou entier arrondi).

Formule Haversine

où

• r est le rayon de la sphère (supposons que le rayon de la Lune est de 1737 km),
• ϕ1 latitude du point 1 en radians
• ϕ2 latitude du point 2 en radians
• λ1 longitude du point 1 en radians
• λ2 longitude du point 2 en radians
• d est la distance circulaire entre les deux points

(source: https://en.wikipedia.org/wiki/Haversine_formula )

Autres formules possibles

• d = r * acos(sin ϕ1 sin ϕ2 + cos ϕ1 cos ϕ2 cos(λ2 - λ1)) Formule de @miles .
• d = r * acos(cos(ϕ1 - ϕ2) + cos ϕ1 cos ϕ2 (cos(λ2 - λ1) - 1)) La formule de @Neil .

Exemple où les entrées sont des degrés et la sortie sous forme d'entier arrondi

42, 9, 50, 2  --> 284
50, 2, 42, 9  --> 284
4, -2, -2, 1  --> 203
77, 8, 77, 8  --> 0
10, 2, 88, 9  --> 2365

Règles

• L'entrée et la sortie peuvent être données dans n'importe quel format pratique .
• Spécifiez dans la réponse si les entrées sont en degrés ou en radians .
• Pas besoin de gérer des valeurs de latitude / longitude invalides
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Si possible, veuillez inclure un lien vers un environnement de test en ligne afin que d'autres personnes puissent essayer votre code!
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Wolfram Language (Mathematica) , 48 octets

ArcCos[Sin@#*Sin@#3+Cos[#2-#4]Cos@#*Cos@#3]1737&

Essayez-le en ligne!

Utilise la formule d = r * acos( sin ϕ1 sin ϕ2 + cos ϕ1 cos ϕ2 cos(λ2 - λ1) )oùr = 1737

Géosphère R + , 54 47 octets

function(p,q)geosphere::distHaversine(p,q,1737)

Essayez-le en ligne!

Prend l'entrée en tant que vecteurs à 2 éléments longitude,latitudeen degrés. TIO n'a pas le geospherepackage mais soyez assuré qu'il renvoie des résultats identiques à la fonction ci-dessous.

Merci à Jonathan Allan d'avoir rasé 7 octets.

R , 64 octets

function(p,l,q,k)1737*acos(sin(p)*sin(q)+cos(p)*cos(q)*cos(k-l))

Essayez-le en ligne!

Prend 4 entrées comme dans les cas de test, mais en radians plutôt qu'en degrés.

JavaScript (Node.js) , 65 octets

(a,b,c,d,C=Math.cos)=>1737*Math.acos(C(a-c)+C(a)*C(c)*(C(d-b)-1))

Essayez-le en ligne!

D'après la réponse de Kevin Cruijssen, les commentaires de Miles et Neil et à la demande d'Arnauld.

JavaScript (ES7), 90 octets

Remarque: voir l'article de @ OlivierGrégoire pour une solution beaucoup plus courte

Un port direct de la réponse de TFeld . Prend l'entrée en radians.

(a,b,c,d,M=Math)=>3474*M.asin((M.sin((c-a)/2)**2+M.cos(c)*M.cos(a)*M.sin((d-b)/2)**2)**.5)

Essayez-le en ligne!

Utilisation de l'infâme with(), 85 octets

Merci à @ l4m2 pour avoir économisé 6 octets

with(Math)f=(a,b,c,d)=>3474*asin((sin((c-a)/2)**2+cos(c)*cos(a)*sin((d-b)/2)**2)**.5)

Essayez-le en ligne!

APL (Dyalog Unicode) , 40 35 octets ^SBCS

Fonction tacite anonyme. Prend {ϕ₁, λ₁} comme argument de gauche et {ϕ₂, λ₂} comme argument de droite.

Utilise la formule 2 r √ (sin² ( ^{(ϕ₁-ϕ₂)} ⁄ ₂ ) + cos ϕ₁ cos ϕ₂ sin² ( ^{(λ₁ - λ₂)} ⁄ ₂ ))

3474ׯ1○.5*⍨1⊥(×⍨1○2÷⍨-)×1,2×.○∘⊃,¨

Essayez-le en ligne! (la rfonction convertit les degrés en radians)

,¨ concaténer les éléments correspondants; {{ϕ₁, ϕ₂}, {λ₁, λ₂}}

⊃ choisissez le premier; {ϕ₁, ϕ₂}

∘ puis

2×.○ produit de leurs cosinus; cos ϕ₁ cos ϕ₂
 ^{lit. point "produit" mais avec sélecteur de fonction trig (2 est cosinus) au lieu de multiplication et fois au lieu de plus}

1, ajouter 1 à cela; {1, cos ϕ₁ cos ϕ₂}

(… )× Multipliez cela par le résultat de l'application de la fonction suivante à {ϕ₁, λ₁} et {ϕ₂, λ₂}:

 - leurs différences; {ϕ₁ - ϕ₂, λ₁ - λ₂}

 2÷⍨ divisez cela par 2; { ^{(ϕ₁ - ϕ₂)} ⁄ ₂ , ^{(λ₁ - λ₂)} ⁄ ₂ }

 1○ sinus de cela; {sin ( ^{(ϕ₁ - ϕ₂)} ⁄ ₂ ), sin ( ^{(λ₁ - λ₂)} ⁄ ₂ )}

 ×⍨ carré qui (lit. auto-multiplié); {sin² ( ^{(ϕ₁ - ϕ₂)} ⁄ ₂ ), sin² ( ^{(λ₁-λ₂)} ⁄ ₂ )}

Nous avons maintenant {sin² ( ^{(ϕ₁ - ϕ₂)} ⁄ ₂ ), cos ϕ₁ cos ϕ₂ sin² ( ^{(λ₁ - λ₂)} ⁄ ₂ )}

1⊥ somme que (lit. évaluer en base-1); sin² ( ^{(ϕ₁-ϕ₂)} ⁄ ₂ ) + cos ϕ₁ cos ϕ₂ sin² ( ^{(λ₁ - λ₂)} ⁄ ₂ )

.5*⍨ racine carrée de cela (lit. élever cela à la puissance d'un demi)

 ¯1○ arcsinus de cela

 3474× multiplier cela par ce

La fonction permettant d'autoriser la saisie en degrés est:

○÷∘180

÷180 argument divisé par 180

○ multiplier par π

Python 2 , 95 octets

lambda a,b,c,d:3474*asin((sin((c-a)/2)**2+cos(c)*cos(a)*sin((d-b)/2)**2)**.5)
from math import*

Essayez-le en ligne!

Prend l'entrée en radians.

Ancienne version, avant que les E / S ne soient relâchées: prend l'entrée en degrés entiers et renvoie une dist arrondie

Python 2 , 135 octets

lambda a,b,c,d:int(round(3474*asin((sin((r(c)-r(a))/2)**2+cos(r(c))*cos(r(a))*sin((r(d)-r(b))/2)**2)**.5)))
from math import*
r=radians

Essayez-le en ligne!

Java 8, 113 92 88 82 octets

(a,b,c,d)->1737*Math.acos(Math.cos(a-c)+Math.cos(a)*Math.cos(c)*(Math.cos(d-b)-1))

Les entrées a,b,c,dsont ϕ1,λ1,ϕ2,λ2en radians.

-21 octets en utilisant la formule plus courte de @miles .
-4 octets grâce à @ OlivierGrégore car je l'ai toujours utilisé {Math m=null;return ...;}avec tous les Math.as m., au lieu de laisser tomber le returnet d'utiliser Mathdirectement.
-6 octets en utilisant la formule plus courte de @Neil .

Essayez-le en ligne.

Explication:

(a,b,c,d)->                  // Method with four double parameters and double return-type
  1737*Math.acos(            //  Return 1737 multiplied with the acos of:
   Math.cos(a-c)             //   the cos of `a` minus `c`,
   +Math.cos(a)*Math.cos(c)  //   plus the cos of `a` multiplied with the cos of `c`
   *(Math.cos(d-b)-1))       //   multiplied with the cos of `d` minus `b` minus 1

Japt , 55 50 octets

MsU *MsW +McU *McW *McX-V
ToMP1/7l¹ñ@McX aUÃv *#­7

Pas nécessairement tout à fait aussi précis que les autres réponses, mais garçon, je me suis amusé avec celle-ci. Permettez-moi de développer.
Alors que dans la plupart des langues, ce défi est assez simple, Japt a la malheureuse propriété qu'il n'y a pas intégré pour ni arcsine ni arccosine. Bien sûr, vous pouvez intégrer Javascript dans Japt, mais ce serait toujours le contraire du Feng Shui.

Tout ce que nous avons à faire pour surmonter cette nuisance mineure, c'est l'arc cosinus approximatif et nous sommes prêts à partir!

La première partie est tout ce qui est introduit dans l'arc cosinus.

MsU *MsW +McU *McW *McX-V
MsU                        // Take the sine of the first input and
    *MsW...                // multiply by the cos of the second one etc.

Le résultat est implicitement stocké Upour être utilisé ultérieurement.

Après cela, nous devons trouver une bonne approximation pour l'arccosine. Puisque je suis paresseux et pas très bon en mathématiques, nous allons évidemment simplement le forcer brutalement.

ToMP1/7l¹ñ@McX aUÃv *#­7
T                       // Take 0
 o                      // and create a range from it
  MP                    // to π
    1/7l¹               // with resolution 1/7!.
         ñ@             // Sort this range so that
           McX          // the cosine of a given value
               aU       // is closest to U, e.g. the whole trig lot
                        // we want to take arccosine of.
                 Ã      // When that's done,
                  v     // get the first element
                    *#­7 // and multiply it by 1737, returning implicitly.

Nous aurions pu utiliser un nombre important pour la résolution du générateur, les tests manuels ont montré qu'il 7!était suffisamment grand tout en étant raisonnablement rapide.

Prend l'entrée en radians, sort des nombres non arrondis.

Rasé cinq octets grâce à Oliver .

Essayez-le en ligne!

Haskell , 68 66 52 51 octets

s=cos;(a!b)c d=1737*acos(s(a-c)+s a*s c*(s(d-b)-1))

Essayez-le en ligne!

-1 octet grâce à BMO

Rubis , 87 70 69 octets

->a,b,c,d{extend Math;1737*acos(cos(a-c)+cos(a)*cos(c)*(cos(d-b)-1))}

Essayez-le en ligne!

Maintenant en utilisant la méthode de Neil, merci à Kevin Cruijssen.

Gelée ,  23 22  18 octets

-4 octets grâce aux miles (utilisation {et }utilisation de leur formule .

;I}ÆẠP+ÆSP${ÆA×⁽£ġ

Une fonction dyadique acceptant [ϕ1, ϕ2,]à gauche et [λ1, λ2]à droite en radians qui renvoie le résultat (en virgule flottante).

Essayez-le en ligne!

Le mien ... (a également enregistré un octet ici en utilisant un {)

,IÆẠCH;ÆẠ{Ḣ+PƊ½ÆṢ×⁽µṣ

Essayez-le en ligne

MATLAB avec Mapping Toolbox, 26 octets

@(x)distance(x{:})*9.65*pi

Fonction anonyme qui prend les quatre entrées comme un tableau de cellules, dans le même ordre que celui décrit dans le défi.

Notez que cela donne des résultats exacts (en supposant que le rayon de la Lune est de 1737 km), car 1737/180égal 9.65.

Exemple exécuté dans Matlab R2017b:

Python 3, 79 octets

from geopy import*
lambda a,b:distance.great_circle(a,b,radius=1737).kilometers

TIO n'a pas geopy.py

APL (Dyalog Unicode) , 29 octets ^SBCS

Programme complet. Demande stdin pour {ϕ₁, ϕ₂} puis pour {λ₁, λ₂}. Imprime à stdout.

Utilise la formule r acos (sin ϕ₁ sin ϕ₂ + cos (λ₂ - λ₁) cos ϕ₁ cos ϕ₂)

1737ׯ2○+/(2○-/⎕)×@2×/1 2∘.○⎕

Essayez-le en ligne! (la rfonction convertit les degrés en radians)

⎕ invite pour {ϕ₁, ϕ₂}

1 2∘.○ Application de fonction trigonométrique cartésienne; {{sin ϕ₁, sin ϕ₂}, {cos ϕ₁, cos ϕ₂}}

×/ produits rangés; {sin ϕ₁ sin ϕ₂, cos ϕ₁ cos ϕ₂}

(… )×@2 Au deuxième élément, multipliez ce qui suit par cela:

 ⎕ invite pour {λ₁, λ₂}

 -/ différence entre ceux-ci; λ₁ - λ₂

 2○ cosinus de cela; cos (λ₁ - λ₂)

Nous avons maintenant {sin ϕ₁ sin ϕ₂, cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂}

+/ somme; sin ϕ₁ sin ϕ₂ + cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂

¯2○ cosinus de cela; cos (sin ϕ₁ sin ϕ₂ + cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂)

1737× multipliez r par cela; 1737 cos (sin ϕ₁ sin ϕ₂ + cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂)

La fonction permettant d'autoriser la saisie en degrés est:

○÷∘180

÷180 argument divisé par 180

○ multiplier par π

C (gcc) , 100 88 65 64 octets

88 → 65 en utilisant la formule de @miles
65 → 64 en utilisant la formule de @ Neil

#define d(w,x,y,z)1737*acos(cos(w-y)+cos(w)*cos(y)*(cos(z-x)-1))

Essayez-le en ligne!

Excel, 53 octets

=1737*ACOS(COS(A1-C1)+COS(A1)*COS(C1)*(COS(D1-B1)-1))

Utilisation de la formule de @ Neil. Entrée en radians.

Homard , 66 octets

def h(a,c,b,d):1737*radians arccos a.sin*b.sin+a.cos*b.cos*cos d-c

Utilise la formule des miles, mais la saisie est en degrés. Cela ajoute une étape supplémentaire de conversion en radians avant de multiplier par rayon.

Python 3 , 119 103 octets

Cela utilise des degrés.

from math import*
def f(L):a,o,A,O=map(radians,L);return 1737*acos(cos(a-A)+cos(a)*cos(A)*(cos(O-o)-1))

Essayez-le en ligne!

PHP , 88 octets

Port d' Oliver réponse

function f($a,$b,$c,$d,$e=cos){return 1737*acos($e($a-$c)+$e($a)*$e($c)*($e($d-$b)-1));}

Essayez-le en ligne!

SmileBASIC, 60 octets

INPUT X,Y,S,T?1737*ACOS(COS(X-S)+COS(X)*COS(S)*(COS(T-Y)-1))