ให้ละติจูด / ลองจิจูดของสองจุดบนดวงจันทร์(lat1, lon1)และ(lat2, lon2)คำนวณระยะทางระหว่างจุดสองจุดในกิโลเมตรโดยใช้สูตรใด ๆที่ให้ผลลัพธ์เช่นเดียวกับสูตรแฮเวอร์ซีน

อินพุต

• ค่าจำนวนเต็มสี่ค่าเป็นlat1, lon1, lat2, lon2องศา (มุม) หรือ
• ทศนิยมสี่ค่าϕ1, λ1, ϕ2, λ2เป็นเรเดียน

เอาท์พุต

ระยะทางเป็นกิโลเมตรระหว่างจุดสองจุด (ทศนิยมด้วยความแม่นยำหรือจำนวนเต็มกลม)

สูตร Haversine

ที่ไหน

• r คือรัศมีของทรงกลม (สมมติว่ารัศมีของดวงจันทร์คือ 1737 กม.)
• ϕ1 ละติจูดของจุด 1 เป็นเรเดียน
• ϕ2 ละติจูดของจุด 2 เป็นเรเดียน
• λ1 ลองจิจูดของจุดที่ 1 ในเรเดียน
• λ2 ลองจิจูดของจุด 2 เป็นเรเดียน
• d คือระยะทางวงกลมระหว่างสองจุด

(ที่มา: https://en.wikipedia.org/wiki/Haversine_formula )

สูตรอื่น ๆ ที่เป็นไปได้

• d = r * acos(sin ϕ1 sin ϕ2 + cos ϕ1 cos ϕ2 cos(λ2 - λ1)) @milesสูตร '
• d = r * acos(cos(ϕ1 - ϕ2) + cos ϕ1 cos ϕ2 (cos(λ2 - λ1) - 1)) @Neilสูตร 's

ตัวอย่างที่อินพุตเป็นองศาและเอาต์พุตเป็นจำนวนเต็มที่ปัดเศษ

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

กฎระเบียบ

• อินพุตและเอาต์พุตจะได้รับในรูปแบบที่สะดวกใด ๆ
• ระบุในคำตอบไม่ว่าจะเป็นปัจจัยการผลิตที่อยู่ในองศาหรือเรเดียน
• ไม่จำเป็นต้องจัดการค่าละติจูด / ลองจิจูดที่ไม่ถูกต้อง
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• หากเป็นไปได้โปรดรวมลิงค์ไปยังสภาพแวดล้อมการทดสอบออนไลน์เพื่อให้ผู้อื่นสามารถลองใช้รหัสของคุณได้!
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการตีกอล์ฟตามปกติและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

ภาษา Wolfram (Mathematica) 48 ไบต์

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

ลองออนไลน์!

ใช้สูตรd = r * acos( sin ϕ1 sin ϕ2 + cos ϕ1 cos ϕ2 cos(λ2 - λ1) )ที่r = 1737

R + geosphere , 54 47 ไบต์

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

ลองออนไลน์!

รับอินพุตเป็นเวกเตอร์ 2 องค์ประกอบlongitude,latitudeในหน่วยองศา TIO ไม่มีgeosphereแพ็คเกจ แต่มั่นใจได้ว่าจะให้ผลลัพธ์ที่เหมือนกันกับฟังก์ชั่นด้านล่าง

ขอบคุณ Jonathan Allan ที่โกนหนวด 7 ไบต์

R , 64 ไบต์

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

ลองออนไลน์!

ใช้ 4 อินพุตเหมือนในกรณีทดสอบ แต่เป็นเรเดียนแทนที่จะเป็นองศา

JavaScript (Node.js) , 65 ไบต์

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

ลองออนไลน์!

จากคำตอบของ Kevin Cruijssen ความคิดเห็นของ Miles และ Neil และตามคำขอของ Arnauld

JavaScript (ES7), 90 ไบต์

หมายเหตุ: ดูโพสต์ของ @ OlivierGrégoireสำหรับวิธีแก้ปัญหาที่สั้นกว่ามาก

พอร์ตโดยตรงจากคำตอบของ TFeld ใช้อินพุตเป็นเรเดียน

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

ลองออนไลน์!

ใช้น่าอับอายwith()85 ไบต์

ขอบคุณ @ l4m2 สำหรับการบันทึก 6 ไบต์

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

ลองออนไลน์!

APL (Dyalog Unicode) , 40 35 ไบต์^SBCS

ฟังก์ชั่นเงียบโดยไม่ระบุชื่อ รับ {ϕ₁, λ₁} เป็นอาร์กิวเมนต์ด้านซ้ายและ {ϕ₂, λ₂} เป็นอาร์กิวเมนต์ที่ถูกต้อง

ใช้สูตร 2 r √ (sin² ( ^{(ϕ₁-ϕ₂)} ⁄ ₂ ) + cos ϕ₁ cos ϕ₂ sin² ( ^{(λ₁ - λ₂)} ⁄ ₂ ))

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

ลองออนไลน์! ( rฟังก์ชั่นแปลงองศาเป็นเรเดียน)

,¨ เรียงต่อกันองค์ประกอบที่สอดคล้องกัน; {{ϕ₁, ϕ₂}, {λ₁, λ₂}}

⊃ เลือกแรก; {ϕ₁, ϕ₂}

∘ แล้วก็

2×.○ ผลิตภัณฑ์ของโคไซน์ของพวกเขา cos ϕ₁ cos ϕ₂
 ^{lit จุด "ผลิตภัณฑ์" แต่มีตัวเลือกฟังก์ชั่นตรีโกณมิติ (2 คือโคไซน์) แทนการคูณและเวลาแทนการบวก}

1, ต่อท้าย 1 ถึงสิ่งนั้น {1, cos ϕ₁ cos ϕ₂}

(... )× คูณด้วยผลของการใช้ฟังก์ชันต่อไปนี้กับ {ϕ₁, λ₁} และ {ϕ₂, λ₂}:

 - ความแตกต่างของพวกเขา; {ϕ₁ - ϕ₂, λ₁ - λ₂}

 2÷⍨ หารด้วย 2; { ^{(ϕ₁ - ϕ₂)} ⁄ ₂ , ^{(λ₁ - λ₂)} ⁄ ₂ }

 1○ ไซน์ของสิ่งนั้น {sin ( ^{(ϕ₁ - ϕ₂)} ⁄ ₂ ), sin ( ^{(λ₁ - λ₂)} ⁄ ₂ )}

 ×⍨ สี่เหลี่ยมจัตุรัสนั้น (สว่างขึ้นคูณตัวเอง); {sin² ( ^{(ϕ₁ - ϕ₂)} ⁄ ₂ ), sin² ( ^{(λ₁-λ₂)} ⁄ ₂ )}

ตอนนี้เรามี {sin² ( ^{(ϕ₁ - ϕ₂)} ⁄ ₂ ), cos ϕ₁ cos ϕ₂ sin² ( ^{(λ₁ - λ₂)} ⁄ ₂ )}

1⊥ รวมว่า (จุดนั้นประเมินผลในฐาน 1); sin² ( ^{(ϕ₁-ϕ₂)} ⁄ ₂ ) + cos ϕ₁ cos ϕ₂ sin² ( ^{(λ₁ - λ₂)} ⁄ ₂ )

.5*⍨ สแควร์รูทของมัน (เพิ่มขึ้นยกกำลังครึ่ง)

 ¯1○ arcsine ของสิ่งนั้น

 3474× คูณด้วยสิ่งนี้

ฟังก์ชั่นเพื่อให้อินพุตเป็นองศาคือ:

○÷∘180

÷180 อาร์กิวเมนต์หารด้วย 180

○ คูณด้วยπ

Python 2 , 95 ไบต์

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*

ลองออนไลน์!

ใช้อินพุตเป็นเรเดียน

เวอร์ชันเก่าก่อนที่ i / o จะถูกหย่อน: ใช้อินพุตเป็นองศาจำนวนเต็มและส่งคืนการปัดเศษแบบปัด

Python 2 , 135 ไบต์

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

ลองออนไลน์!

Java 8, 113 92 88 82 ไบต์

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

อินพุตa,b,c,dอยู่ϕ1,λ1,ϕ2,λ2ในเรเดียน

-21 ไบต์ใช้@milesสูตรสั้น '
-4 ไบต์ต้องขอบคุณ@ OlivierGrégoreเพราะฉันยังคงใช้{Math m=null;return ...;}กับมันทุกMath.อย่างm.แทนที่จะปล่อยreturnและใช้Mathโดยตรง
-6 ไบต์ใช้@Neil 's สูตรสั้น

ลองออนไลน์

คำอธิบาย:

(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 ไบต์

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

ไม่จำเป็นต้องแม่นยำเหมือนคำตอบอื่น ๆ เลย แต่ฉันก็สนุกกับมัน อนุญาตให้ฉันทำอย่างละเอียด
ในขณะที่ภาษาส่วนใหญ่ความท้าทายนี้ค่อนข้างตรงไปตรงมา Japt มีคุณสมบัติที่โชคร้ายที่ไม่มีในตัวสำหรับอาร์คซีนหรืออาร์คโคซีน แน่นอนว่าคุณสามารถฝัง Javascript ใน Japt ได้ แต่นั่นจะเป็นสิ่งที่ตรงกันข้ามกับ Feng Shui

สิ่งที่เราต้องทำเพื่อเอาชนะความรำคาญเล็กน้อยนี้คืออาร์คโคซีนโดยประมาณและเราก็พร้อมที่จะไป!

ส่วนแรกคือทุกอย่างที่ป้อนเข้าสู่อาร์คโคซีน

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.

ผลลัพธ์จะถูกเก็บไว้โดยนัยUเพื่อใช้ในภายหลัง

หลังจากนั้นเราต้องหาอาร์คโคซีนเพื่อการประมาณที่ดี เนื่องจากฉันขี้เกียจและไม่เก่งคณิตศาสตร์เราจึงเห็นได้ชัดว่ากำลังจะดุร้าย

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.

เราสามารถใช้ความละเอียดของตัวกำเนิดจำนวนมากได้การทดสอบด้วยตนเองแสดงให้เห็นว่า7!มีขนาดใหญ่พอสมควรในขณะที่รวดเร็วพอสมควร

รับอินพุตเป็นเรเดียนจะส่งออกตัวเลขที่ไม่มีการล้อมรอบ

โกนห้าไบต์ขอบคุณที่โอลิเวอร์

ลองออนไลน์!

Haskell , 68 66 52 51 ไบต์

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

ลองออนไลน์!

-1 ไบต์ขอบคุณ BMO

ทับทิม , 87 70 69 ไบต์

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

ลองออนไลน์!

ตอนนี้ใช้วิธีของนีลต้องขอบคุณเควินครุยเซอร์

เจลลี่ ,  23 22  18 ไบต์

-4 ไบต์ต้องขอบคุณไมล์ (การใช้{และ}ในขณะที่ใช้สูตรของพวกเขา

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

ฟังก์ชัน dyadic ยอมรับ[ϕ1, ϕ2,]ด้านซ้ายและ[λ1, λ2]ด้านขวาในเรเดียนที่ส่งคืนผลลัพธ์ (เป็นจุดลอย)

ลองออนไลน์!

Mine ... (บันทึกไบต์ที่นี่ด้วยการใช้ a {)

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

ลองออนไลน์

MATLAB พร้อมกล่องเครื่องมือการทำแผนที่ 26 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อที่รับอินพุตทั้งสี่เป็นอาร์เรย์ของเซลล์ตามลำดับเดียวกับที่อธิบายไว้ในความท้าทาย

โปรดทราบว่านี้ให้ผลลัพธ์ที่แน่นอน (สมมติว่ารัศมีดวงจันทร์เป็น 1,737 กิโลเมตร) เพราะเท่ากับ1737/1809.65

ตัวอย่างการรันใน Matlab R2017b:

Python 3, 79 ไบต์

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

TIO ไม่มี geopy.py

APL (Dyalog Unicode) , 29 ไบต์^SBCS

โปรแกรมที่สมบูรณ์ พร้อมต์ stdin สำหรับ {ϕ₁, ϕ₂} และสำหรับ {λ₁, λ₂} พิมพ์ไปยัง stdout

ใช้สูตร r acos (sin ϕ₁ sin ϕ₂ + cos (λ₂ - λ₁) cos ϕ₁ cos ϕ₂)

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

ลองออนไลน์! ( rฟังก์ชั่นแปลงองศาเป็นเรเดียน)

⎕ พรอมต์สำหรับ {ϕ₁, ϕ₂}

1 2∘.○ แอปพลิเคชั่นฟังก์ชันคาร์ทีเซียน {{sin ϕ₁, sin ϕ₂}, {cos ϕ₁, cos ϕ₂}}

×/ ผลิตภัณฑ์แถวที่ชาญฉลาด {sin ϕ₁ sin ϕ₂, cos ϕ₁ cos ϕ₂}

(... )×@2 ที่องค์ประกอบที่สองคูณด้วยสิ่งต่อไปนี้:

 ⎕ พรอมต์สำหรับ {λ₁, λ₂}

 -/ ความแตกต่างระหว่างสิ่งเหล่านั้น λ₁ - λ₂

 2○ โคไซน์ของสิ่งนั้น cos (λ₁ - λ₂)

ตอนนี้เรามี {sin ϕ₁ sin ϕ₂, cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂}

+/ สรุป; บาป ϕ₁ sin ϕ₂ + cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂

¯2○ โคไซน์ของสิ่งนั้น cos (sin ϕ₁ sin ϕ₂ + cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂)

1737× คูณ r ด้วยอันนั้น 1737 cos (sin ϕ₁ sin ϕ₂ + cos (λ₁ - λ₂) cos ϕ₁ cos ϕ₂)

ฟังก์ชั่นเพื่อให้อินพุตเป็นองศาคือ:

○÷∘180

÷180 อาร์กิวเมนต์หารด้วย 180

○ คูณด้วยπ

C (gcc) , 100 88 65 64 ไบต์

88 → 65 ใช้สูตร @miles
65 → 64 ใช้สูตร @ Neil

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

ลองออนไลน์!

Excel, 53 ไบต์

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

ใช้สูตรของ @ Neil ป้อนเป็นเรเดียน

Lobster , 66 ไบต์

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

ใช้สูตรไมล์ แต่อินพุตมีหน่วยเป็นองศา นี่เป็นการเพิ่มขั้นตอนพิเศษในการแปลงเป็นเรเดียนก่อนการคูณด้วยรัศมี

Python 3 , 119 103 ไบต์

สิ่งนี้ใช้องศา

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

ลองออนไลน์!

PHP , 88 ไบต์

พอร์ตของ โอลิเวอร์ตอบ

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

ลองออนไลน์!

SmileBASIC ขนาด 60 ไบต์

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