การใช้ตารางต่อไปนี้ ( ต้นฉบับ ) เขียนโค้ดบางอย่างที่ใช้ชื่อของดาวเคราะห์สองดวงและส่งคืนระยะห่างระหว่างพวกมัน:

+-------------------+---------------+
|      Planets      | Distance (km) |
+-------------------+---------------+
| Mercury -> Venus  |      50290000 |
| Venus -> Earth    |      41400000 |
| Earth -> Mars     |      78340000 |
| Mars -> Jupiter   |     550390000 |
| Jupiter -> Saturn |     646270000 |
| Saturn -> Uranus  |    1448950000 |
| Uranus -> Neptune |    1627450000 |
| Neptune -> Pluto  |    1405380000 |
+-------------------+---------------+

ตัวอย่างอินพุตจากนั้นเอาต์พุต:

Mercury, Mars
170030000

Neptune, Jupiter
-3722670000

Earth, Earth
0

สังเกตเครื่องหมายลบที่นั่นเนื่องจากดาวพฤหัสมาก่อนดาวเนปจูน พวกเขายังเป็นจำนวนเต็มทั้งหมด

ดาวพลูโตไม่จำเป็นต้องรวม (ส่วนใหญ่เป็นเพราะวงโคจรแปลก ๆ ซึ่งทำให้ยากต่อการคำนวณระยะทาง - ระยะทางที่กำหนดคือการคำนวณของฉันเอง แต่เนื่องจากพลูโตมีชื่อเสียงในขณะนี้ ... )

โดยระยะทางระหว่างดาวเคราะห์ฉันหมายถึงการโคจร - ฉันไม่ได้คาดหวังว่าวันที่และการทำงานว่าพวกเขาอยู่ที่ไหน

นี่คือรหัสกอล์ฟรหัสที่สั้นที่สุดชนะ

CJam, 54 51 44 ไบต์

2{"X84VT:Z/3KD'Y->>6\ Ta "3/r26b93%=70be4}*-

ลองใช้ออนไลน์ในล่าม CJam

ความคิด

เราใช้ฟังก์ชันการแปลงแป้นอย่างง่ายเพื่อระบุดาวเคราะห์ทั้งแปด โดยการพิจารณาชื่อแต่ละชื่อให้เป็นอาร์เรย์ของจุดโค้ดของมันแปลงจากฐาน 26 เป็นจำนวนเต็มและรับโมดูโลผลลัพธ์ 93 จากนั้นโมดูโล 8, ดาวพุธ , ดาวศุกร์ , โลกฯลฯ เป็นแผนที่2 , 4 , 0 , 1 , 3 , 5 , 6และ7

ตอนนี้เราเลือกจุดที่อยู่ห่างจากเนปจูน 320,000 กม. และคำนวณระยะทางของดาวเคราะห์ทั้งแปดไปยังจุดนั้น หลังจากปล่อยศูนย์สี่ท้ายและเรียงลำดับดาวเคราะห์ใหม่เพื่อให้พอดีกับดัชนี 8 ตัวจากด้านบนเราจะได้อาร์เรย์

[435172 427338 444341 372299 439312 307672 162777 32]

ซึ่งถ้าเราเข้ารหัสแต่ละจำนวนเต็มในฐาน 70 ให้ผลดังนี้:

[
   [1 18 56 52] [1 17 14 58] [1 20 47 51] [1 5 68 39]
   [1 19 45 62] [  62 55 22] [  33 15 27] [       32]
]

โปรดทราบว่า(A B)สามารถแทนที่ตัวเลขสองหลักที่อยู่ติดกันได้((A-1) (B+70))เราสามารถปรับเปลี่ยนอาร์เรย์จากด้านบนเพื่อให้จำนวนเต็มทั้งหมดสามารถเข้ารหัสเป็นอักขระ ASCII ที่พิมพ์ได้:

["X84" "VT:" "Z/3" "KD'" "Y->" ">6\\" " Ta" " "]

รหัส

2{                         e# Do twice:   
  "X84VT:Z/3KD'Y->>6\ Ta " e#   Push that string.
  3/                       e#   Chop it into chunks of length 3.
  r                        e#   Read a token from STDIN.
  26b                      e#   Convert from base 26 to integer.
  93%                      e#   Take the result modulo 93.
  =                        e#   Retrieve the chunk at that index.
  70b                      e#   Convert from base 70 to integer.
  e4                       e#   Multiply by 10,000.
}*                         e#
-                          e# Subtract the two results.

Python 2, 149 147 142 138 128 123 119 ไบต์

ใช้การค้นหาง่าย ๆ เพื่อหาว่าระยะทางใดที่จะใช้ :) นี่เป็นการกำหนดฟังก์ชั่นที่ไม่ระบุตัวตนดังนั้นหากต้องการใช้คุณจะต้องตั้งชื่อ

ขอบคุณ Sp3000 สำหรับไอเดียที่ช่วยประหยัดจำนวนไบต์!

lambda*x:int.__sub__(*[[0,5029,9169,17003,72042,136669,281564,444309]['MeVeEaMaJuSaUr'.find(k[:2])/2]for k in x])*~9999

เยื้องอย่างถูกต้องและไม่อัปโหลดเล็กน้อยเพื่อให้อ่านง่าย:

def f(*x):
 d=0,5029,9169,17003,72042,136669,281564,444309
 a,b=[d['MeVeEaMaJuSaUr'.find(k[:2])/2]for k in x]
 print(b-a)*10000

โทรเช่น:

f("Mercury","Mars")    -> 170030000
f("Neptune","Jupiter") -> -3722670000L

Prolog, 190 174 151 bytes

ขอบคุณ Fatalize สำหรับคำแนะนำ

g(A,X):-sub_atom(A,2,2,_,B),member(B:X,[rc:0,nu:5029,rt:9169,rs:17003,pi:72042,tu:136669,an:281564,pt:444309]).
s(A,B,R):-g(A,X),g(B,Y),R is(Y-X)*10^4.

$ gprolog --consult-file src.pro 
| ?- s('Mercury','Mars',R).   
R = 170030000 ? 
yes
| ?- s('Neptune','Jupiter',R).
R = -3722670000 ? 
yes
| ?- s('Earth','Earth',R).    
R = 0 ? 
yes

JavaScript (ES6), 115 110 ไบต์

(x,y,g=k=>"Me0Ve5029Ea9169Ma17003Ju72042Sa136669Ur281564Ne444309".match(k[0]+k[1]+"(\\d*)")[1]*1e4)=>g(y)-g(x)

นี้เป็นฟังก์ชั่นที่ไม่ระบุชื่อดังนั้นคุณจะต้องเก็บไว้ในตัวแปร ( f=...; f("Earth", "Mercury")) หรือใช้เป็นแสดงออก parenthesised (...)("Earth", "Mercury")(

สตริงยุ่งนั้นเป็นตัวอักษรสองตัวแรกของแต่ละดาวเคราะห์ตามด้วยระยะทางของดาวเคราะห์ดวงนั้นจากดาวพุธ (หารด้วย 10,000 เพื่อประหยัดพื้นที่) ฟังก์ชันภายในgทำสิ่งต่อไปนี้:

1. ใช้ชื่อ ( k)
2. ย่อให้เหลือสองตัวอักษรแรก ( k[0]+k[1])
3. ใช้การจับคู่ regex เพื่อค้นหาระยะห่างที่สอดคล้องกันจากปรอทหารด้วย 10,000 (เช่นดูเหมือนว่า "Earth" regex Ea(\d*))
4. คูณค่าด้วย 10000 ( 1e4) และส่งคืนผลลัพธ์

โดยการลบระยะทางหนึ่งจากดาวพุธเราจะได้ระยะห่างระหว่างดาวเคราะห์

Java, 274 272 264 ไบต์ (รวมพลูโต!)

  void p(String p,String l){String q="MeVeEaMaJuSaUrNePl";int w=q.indexOf(p.substring(0,2))/2,e=q.indexOf(l.substring(0,2))/2,m=1,t=e,d[]={5029,4140,7834,55039,64627,144895,162745,140538};long h=0;if(w>e){e=w;w=t;m=-1;}for(;e-->w;)h+=d[e]*1e4;System.out.print(h*m);}

Input / Output:

p("Mercury","Mars") --> 170030000
p("Mars","Mercury") --> -170030000
p("Earth","Earth")  --> 0

เว้นระยะและแท็บ:

void p(String p,String l){
    String q="MeVeEaMaJuSaUrNePl";
    int w=q.indexOf(p.substring(0,2))/2,
      e=q.indexOf(l.substring(0,2))/2,
      m=1,
      t=e,
      d[]={5029,4140,7834,55039,64627,144895,162745,140538};
    long h=0;
    if(w>e){
        e=w;
        w=t;
        m=-1;
    }
    for(;e-->w;)
        h+=d[e]*1e4;
    System.out.print(h*m);
}

Python ขนาด 118 ไบต์

n=lambda x:(5029,9169,17003,72042,136669,281564,444309,0)["VeEaMaJuSaUrNe".find(x[:2])/2]*10000
f=lambda a,b:n(b)-n(a)

n เป็นฟังก์ชั่นที่คืนค่าระยะทางจากดาวพุธ

สตริง"VeEaMaJuSaUrNe"เป็นตัวละครสองตัวแรกของชื่อทั้งหมดดาวเคราะห์ยกเว้นปรอท findไม่สามารถหาดาวพุธได้ดังนั้นจะคืนค่า -1 -1/2 ยังคงเป็น -1 ดังนั้นนี่คือองค์ประกอบสุดท้ายใน tuple ซึ่งก็คือ 0

รหัสทดสอบอย่างง่าย:

test = (
    ("Mercury","Venus",50290000),
    ("Venus","Earth",41400000),
    ("Earth","Mars",78340000),
    ("Mars","Jupiter",550390000),
    ("Jupiter","Saturn",646270000),
    ("Saturn","Uranus",1448950000),
    ("Uranus","Neptune",1627450000),
    #("Neptune","Pluto",1405380000),
    ("Mercury","Mars",170030000),
    ("Neptune","Jupiter",-3722670000),
    ("Earth","Earth",0))

for a, b, expect in test:
    print a, "->", b, "=", expect
    assert f(a, b) == expect, f(a, b)

APL, 97 95 85 ไบต์

{1E4×-/(0 5029 9169 17003 72042 136669 281564 444309[{⍵≡'Mars':4⋄'MVEmJSUN'⍳⊃⍵}¨⍵⍺])}

สิ่งนี้สร้างฟังก์ชั่น dyadic ที่ไม่มีชื่อซึ่งนำดาวเคราะห์ต้นกำเนิดมาเป็นอาร์กิวเมนต์ด้านซ้ายและดาวเคราะห์ปลายทางทางด้านขวา

คุณสามารถลองออนไลน์ได้ !

J-- , 226 ไบต์

main {str q = "MeVeEaMaJuSaUrNePl"; int w = q.indexOf (a [0] .subs (0,2)) / 2, e = q.indexOf (a [1] .sub (0,2)) / 2, m = 1, t = e, d [] = {5029,4140,7834,55039,64627,144848,162745,140538}, lg h = 0; @i (w> e) {e = w; w t =; m = -1;} @ f (จ - ^^ W;) H + = d [อี] * 10000; ก้อง (h * เมตร);}

ฉันไม่คิดว่าสิ่งนี้จะนับเมื่อฉันสร้างภาษาในขณะที่คำถามไม่ได้เกิดขึ้น แต่ส่วนใหญ่เป็นการทดสอบว่าฉันบีบอัดโค้ด Java ได้ขนาดเล็กเพียงใด นี้จะโดยสิ้นเชิงและสมบูรณ์ตามออกคำตอบของ DeadChex

นี่คือวิธีการใช้งาน:

$ j-- planets.j-- Mercury Mars
170030000

Pyth - 59 53 ไบต์

เข้ารหัสระยะทางในจุดรหัสยูนิโคด

-Fm*^T4s<CM"Ꭵာẚ훿ﱳ𣗿𧮹"x"MshrJtaN"@d14_Q

การค้นหาชื่อนั้นค่อนข้างเจ๋งเพราะมันวนไปมา ขอบคุณ @Dennis ที่แนะนำให้ดัชนี 14 เป็นการค้นหาที่ไม่มีการชนกัน!

ลองมันนี่เกมออนไลน์

Bash, 140 ไบต์

bc<<<"(-`sed -e 's/,/+/;s/[abd-z]//g;s/Mc/0/g;s/V/5029/g;s/E/9169/g;s/M/17003/g;s/J/72042/g;s/S/136669/g;s/U/281564/g;s/N/444309/g'`)*10^4"

$ bash script.sh 
Mercury, Mars
170030000
$ bash script.sh 
Neptune, Jupiter
-3722670000
$ bash script.sh 
Earth, Earth
0

CoffeeScript, 183 180 ไบต์

f=(a,b)->t=[d=0,5029,4140,7834,55039,64627,144895,162745];n='MeVeEaMaJuSaUrNe';t=(x=n[q='indexOf'](a[..1])/2)<(y=n[q](b[..1])/2)&&t[x+1..y]||t[y+1..x];d+=c*1e4for c in t;x>y&&-d||d

Unminified:

f = (a,b) ->
 t = [d = 0, 5029, 4140, 7834, 55039, 64627, 144895, 162745]
 n = 'MeVeEaMaJuSaUrNe'
 t = if (x = n[q='indexOf'](a[..1]) / 2) < (y = n[q](b[..1]) / 2) then t[x+1..y] else t[y+1..x];
 d += c * 1e4 for c in t
 if x > y then -d else d

ทับทิมขนาด 168 ไบต์

a=ARGV.map{|e|e=='Mars'?3:%w(M V E m J S U N P).index(e[0])}
p 10000*(a[1]<=>a[0])*[5029,4140,7834,55039,64627,144895,162745,140538][a.min..a.max-1].inject(0){|r,e|r+e}

ARGVมันออกแบบมาเป็นสคริปต์ที่จะเรียกใช้จากบรรทัดคำสั่งจึงใช้ เรียกใช้เป็น

$ ruby planets.rb Mercury Mars
170030000
$ ruby planets.rb Neptune Jupiter
-3722670000
$ ruby planets.rb Earth Earth
0
$ ruby planets.rb Mercury Venus
50290000
$ ruby planets.rb Venus Earth
41400000
$ ruby planets.rb Mercury Mercury
0
$ ruby planets.rb Pluto Pluto
0
$ ruby planets.rb Mercury Pluto
5848470000
$ ruby planets.rb Pluto Mercury
-5848470000

Haskell, 160 158 157 bytes

data P=Mercury|Venus|Earth|Mars|Jupiter|Saturn|Uranus|Neptune deriving Enum
d x=[0,5029,9169,17003,72042,136669,281564,444309]!!fromEnum x
x#y=(d y-d x)*10^4

ตัวอย่างการใช้งาน:

*Main> Neptune # Jupiter
-3722670000

*Main> Mercury # Mars
170030000

วิธีการทำงาน: ฉันกำหนดชนิดข้อมูลใหม่Pโดยที่ชื่อตัวสร้างเป็นชื่อของดาวเคราะห์ ฉันยังใส่มันในEnumชั้นเรียนเช่นฉันได้รับการจับคู่กับจำนวนเต็มผ่านfromEnum(ตามลำดับความหมายเริ่มต้นด้วยMercury->0 ) จำนวนเต็มนี้สามารถใช้เป็นดัชนีสำหรับรายการระยะทาง

แก้ไข: @Kritzefitz พบสองไบต์เพื่อบันทึกและ @Alchymist อีกอันหนึ่ง ขอบคุณ!

Julia, 206 203 190 ไบต์

(f,t)->t==f?0:(M(p)=p=="Mars"?4:findin("MVEmJSUN",p[1])[1];T=M(t);F=M(f);(T>F?1:-1)*sum([get(Dict(zip(1:8,[5029,4140,7834,55039,64627,144895,162745,0])),i,0)for i=T>F?(F:T-1):(T:F+1)])*1000)

สิ่งนี้จะสร้างฟังก์ชั่นที่ไม่มีชื่อที่ยอมรับสองสตริงและส่งคืนจำนวนเต็ม หากต้องการเรียกใช้ให้ตั้งชื่อ

คำอธิบาย Ungolfed +:

function planet_distance(p_from, p_to)
    if p_from == p_to
        # Return 0 right away if we aren't going anywhere
        0
    else
        # Define a function to get the planet's order in the solar system
        M(p) = p == "Mars" ? 4 : findin("MVEmJSUN", p[1])[1]

        # Get indices for origin and destination
        ind_from = M(p_from)
        ind_to = M(p_to)

        # Define a dictionary to look up distances by index
        D = Dict(zip(1:8,[5029,4140,7834,55039,64627,144895,162745,0])

        # Determine whether the distance will be positive or negative
        # and the range over which we'll sum distances
        if ind_to > ind_from
            coef = 1
            range = ind_from:ind_to-1
        else
            coef = -1
            range = ind_to:ind_from+1
        end

        # Sum the distances between points
        coef * sum([get(D, i, 0) for i in range]) * 1000
    end
end

ชวา 257 228 ไบต์

enum Z{Mercury(0),Venus(5029),Earth(9169),Mars(17003),Jupiter(72042),Saturn(136669),Uranus(281564),Neptune(444309),Pluto(584847);long r;Z(long x){r=x*10000;}static long d(String...s){return Z.valueOf(s[1]).r-Z.valueOf(s[0]).r;}}

static long d(String...s){...}แก้ปัญหาความท้าทาย ข้อมูลป้อนเข้าต้องการชื่อดาวเคราะห์เพื่อจับคู่ชื่อค่าคงที่ของ enum อย่างแน่นอน ฉันชอบวิธีที่จาวาให้สตริงวิธีการแปลง enum สำหรับฉัน <3

การใช้งาน:

Z.d("Mercury","Pluto") ผลตอบแทน 5848470000

Z.d("Pluto","Mercury") ผลตอบแทน -5848470000

Z.d("Uranus","Neptune") ผลตอบแทน 1627450000

Z.d("Mars","Pluto") ผลตอบแทน 5678440000

มาโครตัวประมวลผลล่วงหน้าC (gcc)ขนาด 146 ไบต์

char*p="(3$,?2'+";D[]={0,5029,9169,17003,72042,136669,281564,444309,584847};	
#define E(x)D[strchr(p,*x^x[1])-p]
#define f(s,t)(E(t)-E(s))*10000LL

ลองออนไลน์!