Aşağıdaki tabloyu kullanarak ( kaynak ) iki gezegenin ismini alan ve aralarındaki mesafeyi döndüren bir kod yazın:

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

Örnekler, girdi sonra çıktı:

Mercury, Mars
170030000

Neptune, Jupiter
-3722670000

Earth, Earth
0

Jüpiter'in Neptün'den önce geldiği noktadaki negatif işareti not edin. Ayrıca hepsi tam sayıdır.

Pluto dahil edilmek zorunda değil (çoğunlukla mesafeyi hesaplamayı zorlaştıran tuhaf bir yörüngeden dolayı - verilen mesafe benim hesaplamam, ancak Pluto'nun şu an ünlü olduğu gibi ...).

Gezegenler arasındaki mesafelere göre, yörüngeye dönüyorum - bir tarih beklemiyorum ve nerede olduklarını çözemiyorum.

Bu kod golf, en kısa kod kazanır.

CJam, 54 51 44 bayt

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

CJam tercümanında çevrimiçi olarak deneyin .

Fikir

Sekiz gezegenin tümünü tanımlamak için basit bir karma işlevi kullanıyoruz. Her bir ismi kod noktalarının dizisi olarak kabul ederek, onları taban 26'dan tam sayıya dönüştürmek ve sonuç modulo 93'ü sonra modulo 8, Merkür , Venüs , Dünya , vb. Haritayı 2 , 4 , 0 , 1 , 3 , 5 , 6 ve 7 .

Şimdi, Neptün'ün 320.000 km gerisinde kalan bir nokta seçiyoruz ve sekiz gezegenin tümünün o noktaya olan mesafesini hesaplıyoruz. Dört sondaki sıfırı bıraktıktan ve gezegenleri yukarıdan 8 endeksle uyacak şekilde yeniden düzenledikten sonra diziyi elde ederiz.

[435172 427338 444341 372299 439312 307672 162777 32]

bu, her bir tamsayı 70 tabanında kodlarsak, aşağıdakileri verir:

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

İki bitişik hanenin (A B)değiştirilebileceğini hatırlayarak, ((A-1) (B+70))tüm tam sayıların yazdırılabilir ASCII karakterleri olarak kodlanabilmesi için diziyi yukarıdan değiştirebiliriz:

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

kod

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 Bayt

Yalnızca hangi mesafelerin kullanılacağını bulmak için basit bir arama kullanılır :) Bu adsız bir işlevi tanımlar, bu nedenle onu kullanmak için bir ad vermeniz gerekir.

Bir sürü bayttan tasarruf sağlayan fikirler için Sp3000'e teşekkürler!

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

Düzgün bir şekilde girintili ve okunabilirlik için hafifçe asılmış:

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

Öyle arayın:

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

Prolog, 190 174 151 bayt

Rehberlik için Fatalize için teşekkürler.

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 bayt

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

Bu anonim bir işlevdir, bu nedenle onu bir değişkende ( f=...; f("Earth", "Mercury")) saklamanız veya parantez içine alınmış bir ifade olarak kullanmanız gerekir ( (...)("Earth", "Mercury").

Bu dağınık dize, her gezegenin ilk iki harfinden sonra, gezegenin Merkür'den olan mesafesini takip ediyor (10000 bölü, yer kazanmak için). İç işlev gaşağıdakileri yapar:

1. bir isim alır ( k),
2. İlk iki harfe indirgiyor ( k[0]+k[1]),
3. Merkür'den karşılık gelen mesafeyi bulmak için 10000'e bölünen bir regex eşleştirmesi kullanır (örneğin, "Dünya" regex benziyor Ea(\d*)),
4. değeri 10000 ( 1e4) ile çarpar ve sonucu döndürür.

Bir Merkür mesafesini diğerinden çıkararak gezegenler arasındaki mesafeyi elde ederiz.

Java, 274 272 264 bayt (Pluto dahil)

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

Giriş çıkış:

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

Aralıklı ve sekmeli:

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 bayt

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 Merkür'den uzaklığı döndüren bir işlevdir.

Dizi "VeEaMaJuSaUrNe", Merkür hariç tüm gezegen isimlerinin ilk iki karakteridir . findMerkür bulamıyor, -1 döndürür. -1/2, hala -1'dir, bu, dizideki son eleman olan 0'dır.

Basit test kodu:

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 bayt

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

Bu, kaynak gezegeni sol argüman ve hedef gezegeni sağa alan adsız bir ikili fonksiyon oluşturur.

Şunları yapabilirsiniz çevrimiçi denemek !

J , 226 bayt

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; @ (w> e) {e = w; w t = m = 1;} f @ (; - e ^^ a;) h + = D [e] * 10000; eko (h * m);}

Bunun soru dışındayken dili yaptığım gibi sayıldığını sanmıyorum, ancak çoğunlukla Java kodunu ne kadar küçük sıkıştıracağımın bir sınavıydı. Bu tamamen ve tamamen DeadChex'in cevabına dayanıyor .

İşte nasıl kullanılacağı:

$ j-- gezegenler.j-- Merkür Mars
170030000

Pyth - 59 53 bayt

Unicode kod noktalarındaki mesafeyi kodlar.

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

İsim arama biraz havalı, çünkü etrafta dolaşıyor. Dizin 14'ü çarpışma ücretsiz araması olarak önerdiğiniz için @Dennis'e teşekkür ederiz!

Burada çevrimiçi deneyin .

Bash, 140 bayt

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 bayt

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

Ruby, 168 bayt

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}

Komut satırından çalıştırılacak bir komut dosyası olarak tasarlanmıştır, bu nedenle kullanır ARGV. Olarak çalıştırmak

$ 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 bayt

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

Kullanım örneği:

*Main> Neptune # Jupiter
-3722670000

*Main> Mercury # Mars
170030000

Nasıl çalışır: POluşturucu adlarının gezegenlerin adları olduğu yeni bir veri türü tanımlarım . Ayrıca Enumsınıfa koydum , yani tamsayılar üzerinden bir eşleme elde ettim fromEnum(tanım sırasına göre Mercury-> ile başlayan 0). Bu tamsayı mesafe listesi için bir indeks olarak kullanılabilir.

Düzenleme: @Kritzefitz kaydetmek için iki bayt bulundu ve başka bir tane @Alchymist. Teşekkürler!

Julia, 206 203 190 bayt

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

Bu, iki dizeyi kabul eden ve bir tamsayı döndüren adsız bir işlev oluşturur. Aramak için bir isim verin.

Ungolfed + açıklama:

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

Java, 257 228 bayt

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){...}zorluğu çözer. Girdi, enum sabitlerinin isimleriyle tam olarak uyması için gezegenlerin isimlerini gerektirir. Java'nın benim için dönüşüm yöntemini numaralandırmak için nasıl bir dize sağladığını seviyorum <3

Kullanımı:

Z.d("Mercury","Pluto") döner 5848470000

Z.d("Pluto","Mercury") döner -5848470000

Z.d("Uranus","Neptune") döner 1627450000

Z.d("Mars","Pluto") döner 5678440000

C (gcc) ön işlemci makrosu, 146 bayt

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

Çevrimiçi deneyin!