25

निम्न तालिका ( स्रोत ) का उपयोग करते हुए कुछ कोड लिखें जो दो ग्रहों के नाम लेते हैं और उनके बीच की दूरी लौटाते हैं:

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

नकारात्मक संकेत पर ध्यान दें, क्योंकि बृहस्पति नेपच्यून से पहले आता है। वे सभी पूर्णांक भी हैं।

प्लूटो को शामिल करने की आवश्यकता नहीं है (ज्यादातर एक अजीब कक्षा के कारण जो दूरी तय करना कठिन बनाता है - जो दूरी दी गई है वह मेरी अपनी गणना है, लेकिन जैसा कि प्लूटो अब सभी प्रसिद्ध है ...)।

ग्रहों के बीच की दूरी से मैं अर्थ ऑर्बिट करता हूं - मुझे एक तिथि की उम्मीद नहीं है और वे जहां हैं वहां काम कर रहे हैं।

यह कोड गोल्फ, सबसे छोटा कोड जीत है।

code-golf kolmogorov-complexity

— टिम
स्रोत

10

+1 नहीं "coz प्लूटो एक ग्रह नहीं है" के लिए

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र मैं एक ऐसी परियोजना कर रहा हूँ जिसमें दूरियों की आवश्यकता है और कोई भी सहमत नहीं हो सकता है! मैंने इसे कक्षीय अवधि और कक्षीय गति का उपयोग करने का सहारा लिया ...

— टिम

क्या हमारा कार्य / कार्यक्रम एक फ्लोट लौटा सकता है? यानी Mercury, Mars -> 170030000.0?

— काडे

8

यह निहित है, लेकिन क्या हम उस समय को पवित्र क्षण मान रहे हैं जहां ग्रह सभी एक सीधी रेखा में हैं और किसी भी दो गैर-आसन्न ग्रहों के बीच की दूरी के बीच की दूरी का योग है?

— Sp3000

3

क्या प्लूटो (बाइट्स के अलावा) के लिए जुर्माना है? मुझे लगता है कि इसके लिए थोड़े बुरा लगता है, यह बस बड़ा दिन था और सभी ...

— डेडचेक्स

24

CJam, 54 51 44 बाइट्स

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

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

हम सभी आठ ग्रहों की पहचान करने के लिए एक साधारण हैशिंग फ़ंक्शन का उपयोग करते हैं। प्रत्येक नाम को उसके कोड बिंदुओं की सारणी के रूप में मानकर, उन्हें आधार 26 से पूर्णांक में परिवर्तित करके और परिणाम modulo 93 को फिर modulo 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.

— डेनिस
स्रोत

10

पायथन 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

पठनीयता के लिए सही ढंग से और ungolfed का संकेत दिया गया:

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

— Kade
स्रोत

आपका आउटपुट 0 याद कर रहा है, लेकिन आप सही मात्रा से गुणा कर रहे हैं।

— टिम

@ मैं उदाहरण कॉल में गड़बड़ कर दिया, यह अंत में एक चौथा 0 है: पी

— केड

आप प्लूटो को भूल रहे हैं?

— विल

@Will प्लूटो को शामिल करने की आवश्यकता नहीं है ...

— केड

(यदि आप कॉपी करते हैं तो आप कम से कम दो बाइट्स बचाएंगे, जो कि मेरी प्रविष्टि से -1 ट्रिक को वापस पाते हैं, और फिर आप मुझे आगे खींच लेंगे :)

— विल

8

प्रोलॉग, 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

— SteelRaven
स्रोत

आप s(A, B, R)लेखन के बजाय इस परिणाम को सीधे इस तरह क्यों नहीं लौटाते R? आउटपुट के लिए कुछ भी निर्दिष्ट नहीं है, इसलिए एक विधेय रिटर्न ठीक होना चाहिए।

— घातक

आप ग्रहों के लिए सभी तथ्यों को संशोधित gकरने 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]).और हटाने के लिए 22 बाइट्स से दाढ़ी बना सकते हैं । यह कम से कम शांत है, =..लेकिन यह कुंजी-मूल्य मानचित्रण प्राप्त करने के लिए कम है

— घातक

7

जावास्क्रिप्ट (ईएस 6), 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 निम्नलिखित करता है:

एक नाम लेता है (k ),
इसे पहले दो अक्षरों में घटाता है (k[0]+k[1] ),
10000 से विभाजित, बुध से संबंधित दूरी जानने के लिए एक रेगेक्स मैच का उपयोग करता है (जैसे, "अर्थ" रेगेक्स दिखता है) Ea(\d*) )
मूल्य को 10000 से गुणा करता है (1e4 और परिणाम देता है।

एक बुध-दूसरे से दूरी घटाकर, हम ग्रहों के बीच की दूरी प्राप्त करते हैं।

— apsillers
स्रोत

@ विहान १० ,६ अहा, मैंने वास्तविक बाइट प्रतिनिधित्व के साथ कोड-पॉइंट-वैल्यू को भ्रमित करने का क्लासिक दोष बनाया है :(

— अप्सिलर्स

1

इस ट्रिक के लिए UTF-8 सिर्फ गलत एन्कोडिंग है। सभी वर्णों के द्वारा btoaदिए गए कोड अंक 256 से नीचे हैं, इसलिए ISO 8859-1 एक एकल बाइट का उपयोग करके प्रत्येक वर्ण को कूटबद्ध करेगा।

— डेनिस

7

जावा, 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);
}

— DeadChex
स्रोत

1

आप सभी संख्याओं को 1000 से विभाजित करके बहुत कुछ काट सकते हैं

— टिम

बस ऐसा करने के लिए!

— डेडचेक्स

1

तुम भी दोनों डाल सकते हैं intऔर int[]जैसा: एक लाइन पर घोषणाओं यदि सरणी पिछले आता हैint i=0,j=1,k[]={};

— Geobits

1

के 10000साथ बदलकर आप दो बाइट्स शेव कर सकते हैं 1e4।

— ऑबियन नोब जूल

1

चूँकि हम जानते e > wहैं कि आप ऑपरेटर के पास जाते हुए एक पात्र को ट्रिम कर सकते हैं: while(e-->w)जो कि १२ अक्षर है, for(;e--!=w;)जिसके बजाय १३ है।

— corsiKa

6

अजगर, 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" सभी ग्रह नामों के पहले दो अक्षर हैं । पारा नहीं मिल रहा है इसलिए -1 लौट आएगा। -1/2 अभी भी -1 है इसलिए यह टपल में अंतिम तत्व है, जो कि 0 है।find

सरल परीक्षण कोड:

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)

— मर्जी
स्रोत

अच्छी चाल है।

— अबियान नोब जूल

6

एपीएल, 97 95 85 बाइट्स

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

यह एक अनाम डायैडिक फ़ंक्शन बनाता है जो मूल ग्रह को बाएं तर्क के रूप में और गंतव्य ग्रह को दाईं ओर ले जाता है।

आप इसे ऑनलाइन आज़मा सकते हैं !

— एलेक्स ए।
स्रोत

4

J-- , 226 बाइट्स

मुख्य {str q = "MeVeEaMaJuSaUrNePl"; int w = q.indexOf (a [0] .subs (0,2)) / 2, e = q.indexff (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; = टी; मीटर = -1;} @ f (; ई - ^^ डब्ल्यू;) ज + = घ [ई] * 10000; गूंज (ज * मी);}

मुझे नहीं लगता कि यह मायने रखता है क्योंकि मैं सवाल करते समय भाषा बना रहा था, लेकिन यह ज्यादातर परीक्षण था कि मैं जावा कोड को कितना छोटा कर सकता था। यह पूरी तरह से और पूरी तरह से डेडशीक्स के जवाब पर आधारित है ।

इसका उपयोग कैसे करें:

$ j-- ग्रह ।j-- बुध मंगल
170030000

— अवस्था
स्रोत

4

पायथ - 59 53 बाइट्स

यूनिकोड कोडपॉइंट्स में दूरी को एनकोड करता है।

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

नाम लुकअप थोड़े शांत है क्योंकि यह चारों ओर घूमता है। इंडेक्स 14 को टक्कर मुक्त लुकअप के रूप में सुझाने के लिए @ डेनिस का धन्यवाद!

इसे यहाँ ऑनलाइन प्रयास करें ।

— Maltysen
स्रोत

मैंने अपने पहले संशोधन में सूचकांक 14 का उपयोग किया। यह टकराव मुक्त है।

— डेनिस

3

बैश, 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

— SteelRaven
स्रोत

3

कॉफीस्क्रिप्ट, 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

— rink.attendant.6
स्रोत

3

रूबी, 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

— कार्स्टन एस।
स्रोत

3

हास्केल, 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 को एक और। धन्यवाद!

— nimi
स्रोत

आप चारों ओर कोष्ठकों को हटा सकते हैं fromEnum xऔर दो बाइट्स बचा सकते हैं।

— क्रिट्ज़फ़िट्ज़

क्या आप 10000 के बजाय 10 ^ 4 का उपयोग कर सकते हैं या इससे आउटपुट प्रभावित होगा?

— एल्काइमेस्ट जू

@ ऐल्मिस्ट: हाँ, यह संभव है। धन्यवाद!

— नीमी

2

जूलिया, 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

— एलेक्स ए।
स्रोत

2

जावा, 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){...}चुनौती हल करता है। इनपुट को एनम के स्थिरांक के नामों से मिलान करने के लिए ग्रहों के नामों की आवश्यकता होती है। मैं प्यार करता हूँ कि कैसे जावा मेरे लिए एक स्ट्रिंग प्रदान करता है रूपांतरण विधि <3

उपयोग:

Z.d("Mercury","Pluto") रिटर्न 5848470000

Z.d("Pluto","Mercury") रिटर्न -5848470000

Z.d("Uranus","Neptune") रिटर्न 1627450000

Z.d("Mars","Pluto") रिटर्न 5678440000

— जैक अम्मो
स्रोत

1

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

इसे ऑनलाइन आज़माएं!

— gastropner
स्रोत

दो ग्रहों के नामों को देखते हुए दूरी दें

CJam, 54 51 44 बाइट्स

विचार

कोड

पायथन 2, 149 147 142 138 128 123 119 बाइट्स

प्रोलॉग, 190 174 151 बाइट्स

जावास्क्रिप्ट (ईएस 6), 115 110 बाइट्स

जावा, 274 272 264 बाइट्स (प्लूटो शामिल हैं!)

अजगर, 118 बाइट्स

एपीएल, 97 95 85 बाइट्स

J-- , 226 बाइट्स

पायथ - 59 53 बाइट्स

बैश, 140 बाइट्स

कॉफीस्क्रिप्ट, 183 180 बाइट्स

रूबी, 168 बाइट्स

हास्केल, 160 158 157 बाइट्स

जूलिया, 206 203 190 बाइट्स

जावा, 257 228 बाइट्स

C (gcc) प्री-प्रोसेसर मैक्रो, 146 बाइट्स