다음 표 ( source )를 사용하여 두 행성의 이름을 사용하고 두 행성 사이의 거리를 반환하는 코드를 작성하십시오.

+-------------------+---------------+
|      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 통역사 에서 온라인으로 사용해보십시오 .

생각

간단한 해싱 함수를 사용하여 8 개의 행성을 모두 식별합니다. 각 이름을 코드 포인트의 배열로 고려하여 기준 26에서 정수로 변환하고 결과 modulo 93을 취한 다음 modulo 8, Mercury , Venus , Earth 등을 2 , 4 , 0 , 1 , 3 , 5로 매핑합니다. , 6 및 7 .

이제 우리는 해왕성 뒤에 320,000km 떨어진 지점을 선택하고 그 지점까지의 8 개 행성의 거리를 계산합니다. 4 개의 후행 0을 삭제하고 행성을 위에서 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.

파이썬 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

도입부 190 174 151 바이트

안내를 해주신 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

자바 스크립트 (ES6) 115 110 바이트

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

이것은 익명 함수이므로 변수에 저장해야합니다 (f=...; f("Earth", "Mercury") ) 하거나 괄호로 묶은 표현식 ()으로 사용해야합니다 (...)("Earth", "Mercury").

그 지저분한 끈은 각 행성의 처음 두 글자이며, 수성으로부터의 행성 거리 (10000으로 나누어 공간 절약)가 뒤 따릅니다. 내부 함수 g는 다음을 수행합니다.

1. 이름을 가지고 (k )을
2. 처음 두 글자로 줄입니다 (k[0]+k[1] )로 줄입니다.
3. 정규식 일치를 사용하여 수은에서 해당 거리를 10000으로 나눈 값을 찾습니다 (예 : "지구"정규식은 Ea(\d*) )
4. 값에 10000을 곱합니다 (1e4 )을 결과를 반환합니다.

한 수은 거리를 다른 수은 거리에서 빼면 행성 사이의 거리를 얻습니다.

자바, 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);}

입출력:

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

파이썬, 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 Mercury에서 거리를 반환하는 함수입니다.

문자열 "VeEaMaJuSaUrNe"은 Mercury를 제외한 모든 행성 이름의 처음 두 문자입니다 . find수은을 찾을 수 없으므로 -1을 반환합니다. -1/2는 여전히 -1이므로 튜플의 마지막 요소 인 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'⍳⊃⍵}¨⍵⍺])}

이것은 원 행성을 왼쪽 인수로, 목적지 행성을 오른쪽으로 취하는 명명되지 않은 2 차원 함수를 만듭니다.

당신은 할 수 있습니다 온라인으로보십시오 !

J-- , 226 바이트

main {str q = "MeVeEaMaJuSaUrNePl"; int w = q.indexOf (a [0] .subs (0,2)) / 2, e = q.indexOf (a [1] .subs (0,2)) / 2, m = 1, t = e, d [] = {5029,4140,7834,55039,64627,144895,162745,140538}; lg h = 0; @i (w> e) {e = w; w = t; m = -1;} @ f (; e-^^ w;) h + = d [e] * 10000; echo (h * m);}

질문이 나올 때 언어를 만들 때 이것이 중요하다고 생각하지는 않지만 Java 코드를 압축 할 수있는 크기는 거의 테스트였습니다. 이것은되고 완전히 와 완전히 기반으로 DeadChex의 대답 .

사용 방법은 다음과 같습니다.

j j-행성 j. 수성 화성
170030000

Pyth- 59 53 바이트

거리를 유니 코드 코드 포인트로 인코딩합니다.

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

이름 조회는 반복되기 때문에 다소 멋집니다. 충돌없는 조회로 색인 14를 제안 해 주신 @Dennis에게 감사드립니다!

온라인으로 사용해보십시오 .

배쉬, 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

커피 스크립트, 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

미완성 :

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

하스켈 160 158 157 바이트

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는 다른 바이트를 찾았습니다. 감사!

줄리아 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)

두 개의 문자열을 받아들이고 정수를 반환하는 명명되지 않은 함수를 만듭니다. 전화를 걸려면 이름을 지정하십시오.

언 골프 + 설명 :

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){...}도전을 해결합니다. 입력 값에는 행성의 이름이 열거의 상수 이름과 정확히 일치해야합니다. Java가 나를 위해 변환 방법을 열거하는 문자열을 제공하는 방법을 좋아합니다 <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

온라인으로 사용해보십시오!