"जब हम ब्रह्मांड की यात्रा करते हैं ..."

48

आपको सौर मंडल की 20 सबसे बड़ी वस्तुओं में से एक का नाम दिया जाएगा। आपका कार्य किलोमीटर में व्यक्त अपने त्रिज्या के एक सन्निकटन को वापस करना है।

यह एक कोड-चुनौती है जहां आपके स्कोर में आपके कोड की लंबाई (बाइट्स में) होती है , जो आपके सबसे खराब अनुमान के आधार पर एक दंड अनुपात गुणा किया जाता है । इसलिए, सबसे कम स्कोर जीतता है ।≥1

"जैसा कि हम ब्रह्मांड की यात्रा करते हैं" ब्लैक सब्बाथ द्वारा प्लेनेट कारवां के गीत की अंतिम पंक्ति है , जिसे बाद में पैन्तेरा ने भी कवर किया ।

सौर मंडल की वस्तुएं

स्रोत: विकिपीडिया

NB: रैंक केवल जानकारी के लिए दिया जाता है। इनपुट ऑब्जेक्ट का नाम है।

  n | Object   | Radius (km)
----+----------+-------------
  1 | Sun      |   696342
  2 | Jupiter  |    69911
  3 | Saturn   |    58232
  4 | Uranus   |    25362
  5 | Neptune  |    24622
  6 | Earth    |     6371
  7 | Venus    |     6052
  8 | Mars     |     3390
  9 | Ganymede |     2634
 10 | Titan    |     2575
 11 | Mercury  |     2440
 12 | Callisto |     2410
 13 | Io       |     1822
 14 | Moon     |     1737
 15 | Europa   |     1561
 16 | Triton   |     1353
 17 | Pluto    |     1186
 18 | Eris     |     1163
 19 | Haumea   |      816
 20 | Titania  |      788

या कॉपी-पेस्ट फ्रेंडली सूचियों के रूप में:

'Sun', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Earth', 'Venus', 'Mars', 'Ganymede', 'Titan', 'Mercury', 'Callisto', 'Io', 'Moon', 'Europa', 'Triton', 'Pluto', 'Eris', 'Haumea', 'Titania'
696342, 69911, 58232, 25362, 24622, 6371, 6052, 3390, 2634, 2575, 2440, 2410, 1822, 1737, 1561, 1353, 1186, 1163, 816, 788

अपने स्कोर

चलो की उम्मीद त्रिज्या वस्तु और जाने इस वस्तु के लिए अपने कार्यक्रम के जवाब।RnnthAn

तब आपका स्कोर इस प्रकार परिभाषित किया गया है:

S=⌈L×max1≤i≤20(max(AiRi,RiAi)2)⌉

जहाँ बाइट्स में आपके कोड की लंबाई है।L

उदाहरण:

यदि आपके कोड का आकार बाइट्स है और किमी के बजाय किमी के अनुमानित दायरे के साथ चंद्रमा पर आपका सबसे खराब अनुमान है , तो आपका स्कोर होगा:10010001737

S=⌈100×(17371000)2⌉=302

कम, बेहतर।

आपके उत्तर के लिए अनुशंसित हेडर:

Language, 100 bytes, score = 302

आप अपने स्कोर की गणना करने के लिए इस स्क्रिप्ट का उपयोग कर सकते हैं (पहली पंक्ति = कोड की लंबाई, अगली 20 लाइनें = अपने आउटपुट, सूर्य से टाइटनिया तक)।

नियम

  • आप ऑब्जेक्ट का नाम पूर्ण लोअरकेस, पूर्ण अपरकेस या ठीक ऊपर (शीर्षक मामले) के रूप में ले सकते हैं। अन्य मिश्रित मामलों की अनुमति नहीं है।
  • इनपुट को 20 संभावित नामों में से एक होने की गारंटी है।
  • आप पूर्णांक या फ़्लोट कर सकते हैं। दोनों मामलों में, दंड की गणना सीधे इन मूल्यों के साथ की जानी चाहिए (तैरने के मामले में गोल मान नहीं)।
  • आपको सकारात्मक मान लौटाने होंगे।
  • खाली कार्यक्रमों की अनुमति नहीं है।
code-challenge  approximation 
— Arnauld
स्रोत
2
सैंडबॉक्स (अब हटा दिया गया)। सभी को धन्यवाद जिन्होंने प्रतिक्रिया प्रदान की, और विशेष रूप से स्कोरिंग फॉर्मूले को ठीक करने में मदद के लिए xnor।
— अरनौलड
1
मैं देख रहा हूँ कि स्कोरिंग को अंतर के लिए 2 की शक्ति में बदल दिया गया है? उस स्थिति में मेरा 100-बाइट सटीक उत्तर मेरे 70-बाइट सन्निकटन से छोटा है (जो पहले 91 रन बना चुका था, लेकिन अब 117 ..)
— केविन क्रूज़सेन
1
@KevinCruijssen इसके पीछे का विचार बेहद कम जवाबों को रोकने के लिए था (मूल रूप से 1 या 2 स्थिरांक लौटाना) एक उचित कारक द्वारा दंडित किया जाना और संभवतः अधिक परिष्कृत लोगों के खिलाफ जीतना।
— अरनुलद
2
मैं स्कोरिंग फ़ंक्शन में वर्ग का अनुमोदन करता हूं। मेरा पिछला सर्वश्रेष्ठ परिणाम 7512सभी परीक्षण मामलों के लिए 2 बाइट्स का उपयोग करके 60 का स्कोर था । मैं देखूंगा कि क्या मैं जल्द ही कभी भी मैथगोल्फ समाधान बनाने में गोता लगाऊंगा, लेकिन 05AB1E को हराना मुश्किल होगा।
— अधिकतम
2
@ मैक्सब आपको जेली के 37 के स्कोर को हराना होगा, न कि 05AB1E के 60 के स्कोर को; पी
— केविन क्रूज़सेन

जवाबों:

28

पावरशेल , 3 बाइट्स, स्कोर 3637

2e4

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

बहुत भोला, उबाऊ, कार्यान्वयन; सिर्फ 20000इनपुट से कोई फर्क नहीं पड़ता। सूरज की विशेष आवरण वाली चीजों के साथ प्रयोग करने या 2सभी के बजाय फ्लोटिंग-पॉइंट वैल्यू का उपयोग करने से स्कोर बहुत खराब हो गए क्योंकि कोड की लंबाई किसी भी आकार-तुलना लाभ को ऑफसेट करने के लिए पर्याप्त बढ़ गई।

— AdmBorkBork
स्रोत
3
केपीआई के बारे में आपको बस इतना ही पता होना चाहिए :)
— mazzy 15
12
यह इतने सारे वोट क्यों मिल रहा है ?!
— झबरा
11
@ शैग्गी मैं उस बारे में भी उलझन में हूँ ..: S यह अब तक का सबसे आलसी और उच्चतम स्कोरिंग उत्तर है (इसे व्यक्तिगत AdmBorkBork नहीं लेते हैं , लेकिन मुझे लगता है कि जेली और जावा उत्तर बहुत अधिक उत्तोलन के लायक हैं)। लोग शायद केवल 3 बाइट्स भाग को देखते हैं (या लगता है कि उच्च स्कोर कम से बेहतर है) और बाकी सब को अनदेखा करें। xD सैंडबॉक्स में अरनुल्द की मूल चुनौती विवरण में, यह उत्तर भी संभव नहीं होगा, क्योंकि यह प्रत्येक I / O के लिए 95% की अधिकतम त्रुटि प्रतिशत की अनुमति देता है। ठीक है। नि: शुल्क प्रतिनिधि AdmBorkBork का आनंद लें । ;)
— केविन क्रूज़सेन
6
हालांकि यह सवाल की कसौटी पर खरा उतरता है। मुझे लगता है कि लोग इसे वोट देते हैं क्योंकि यह बहुत स्पष्ट है, बहुतों ने इसके बारे में नहीं सोचा होगा। यह एक त्रुटिपूर्ण रेटिंग प्रणाली के साथ एक चुनौती को भी दर्शाता है, अगर इसका उस तरह से दुरुपयोग किया जा सकता है।
— एलकेन
9
लोग पीपीसीजी के सभी प्रकार के कारणों के लिए अपवाह करते हैं, न कि केवल कच्चे स्कोर के कारण ( उदाहरण के लिए मेरा विशाल Minecraft redstone उत्तर देखें )। मैंने इस उत्तर को उकेरा क्योंकि यह रणनीति के स्पेक्ट्रम के दूर के छोर का एक स्पष्ट, सरल उदाहरण है ("सटीक मानों को वापस करने के लिए स्पेक्ट्रम" बनाम "एक बाइट को वापस करने और जुर्माना लेने के लिए बाइट्स बचाएं")।
— ब्रैड डिक
25

जेली , 34 बाइट्स, स्कोर = 37

OḌ“⁸|5/!‘%ƒị“RNFLOJMjs⁽\u[USJ‘1.1*

इनपुट अपरकेस में है, आउटपुट 1.1 की शक्ति है जिसमें सबसे कम त्रुटि है।

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

यह काम किस प्रकार करता है

OḌ“⁸|5/!‘%ƒị“RNFLOJMjs⁽\u[USJ‘1.1*  Main link. Argument: s (string)

O                                   Ordinal; map the char in s to their code points.
                                        "ERIS" -> [69,82,73,83]
 Ḍ                                  Undecimal; treat the result as an array of digits
                                    in base 10 and convert it to integer.
                                        [69,82,73,83] -> 69000+8200+730+83 = 78013
  “⁸|5/!‘                           Literal; yield [136, 124, 53, 47, 33].
         %ƒ                         Fold the array by modulus, using the computed
                                    integer as initial value.
                                        78013 -> 78013%136%124%53%47%33 = 32
            “RNFLOJMjs⁽\u[USJ‘      Literal; yield [82, 78, 70, 76, 79, 74, 77, ...
                                    106, 115, 141, 92, 117, 91, 85, 83, 74].
           ị                        Retrieve the element from the array to the right,
                                    at the index to the left.
                                    Indexing is 1-based and modular.
                                        32 = 16 (mod 16) -> 'J' = 74
                              1.1*  Raise 1.1 to the computed power.
                                        74 = 1.1**74 = 1156.268519450066
— डेनिस
स्रोत
20

जावा (JDK) , 90 बाइट्स, स्कोर = 97

s->("ýCĄ (ᬺ!˂Fɍ".charAt(s.substring(2).chars().sum()%96%49%25)-7)*100

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

  • यह प्रविष्टि अविभाज्य और बहु-बाइट यूनिकोड वर्णों का उपयोग करती है (लेकिन जावा उन्हें फिर भी स्वीकार करता है)। सटीक कोड के लिए TIO की जाँच करें।
  • इनपुट को शीर्षक-केस होना चाहिए।
  • यह कोड मानों को सर्वश्रेष्ठ कई -100 (कभी-कभी ऊपर, कभी-कभी नीचे) में गोल करता है, ताकि एन्कोड किए जाने पर अंतिम दो अंकों को छोड़ दिया जा सके, और फिर मूल्य को 100 से गुणा करके अनुमानित किया जा सकता है।
  • यह प्रविष्टि 25 कोडपॉइंट स्ट्रिंग (सबसे छोटी स्ट्रिंग जो मुझे मिल सकती है) फिट करने के लिए विभिन्न हैश का उपयोग करती है।

क्रेडिट

  • -48 स्कोर (-45 बाइट्स) केविन क्रूजेसेनString को एक स्पष्ट intसरणी में हार्डकॉइड करने के बजाय सीधे त्रिज्या (100 से विभाजित) को एन्कोडिंग द्वारा धन्यवाद ।
— ओलिवियर ग्रेजायर
स्रोत
3
— केविन क्रूज़सेन
धन्यवाद @ केविनक्रूजसेन! यह एक अच्छा गोल्फ है, जो दशमलव मानों की एक सरणी के बजाय एक स्ट्रिंग में यूनिकोड वर्णों का उपयोग करता है। :-)
— ओलिवियर ग्रेजायर
खुशी है कि मैं मदद कर सकता है, और अच्छा जवाब! :) PS: मैं क्यों जोड़ा गया के लिए के रूप में (...-7): unprintable चरित्र (char)0खाली है तो मैं कुछ जोड़ना था। मैं पहली बार करने की कोशिश की 9और 8एकल अंक में किया जा रहा है, लेकिन 9निश्चित रूप से टैब की दे दी है, कई की आवश्यकता होती है \t(2 बाइट्स प्रत्येक), और 8कोई अनपेक्षित इस्तेमाल किया चरित्र के बारे में एक त्रुटि दे दी है।
— केविन क्रूज़सेन
@KevinCruijssen ईमानदार होने के लिए, मैंने कुछ घंटों के लिए कोशिश की कि आपके गुणन में विस्तार करके *100-700और मूल्यों-जैसे-स्ट्रिंग और उन दो नंबरों के साथ खेलकर बेहतर मान प्राप्त करें , लेकिन वे सबसे अच्छे हैं, वास्तव में, कुछ मूल्य बाइट को कम कर सकते हैं गिनती, लेकिन फिर स्कोर वही रहता है। इतना बेतरतीब पिनपाइंटिंग बना (एक) सबसे अच्छा मामला;)
— ओलिवियर ग्राएगोइरे
अनिर्वचनीय के बारे में बात करो! यह प्रविष्टि वास्तव में मेरे फ़ायरफ़ॉक्स की ओर इशारा करती है कि मैं वास्तव में बाकी पेज को ठीक से नहीं पढ़ सकता :-(
— नील
9

वोल्फ्राम लैंग्वेज 114 103 97 88 86 82 बाइट्स। स्कोर = 114 103 97 89 87 83 अंक

(#&@@EntityValue[Interpreter["AstronomicalObject"]@#,"Radius"]/._String->507)1.61&

कम से कम 6 अंक के लिए धन्यवाद Dennis, कई और अधिक धन्यवाद lirtosiast, और 6 अधिक धन्यवाद user202729।

यद्यपि गणितज्ञ सौर प्रणाली डेटा (साथ ही साथ अतिरिक्त खगोलीय डेटा) प्राप्त कर सकते हैं, कुछ मामूली बारीकियों की आवश्यकता होती है, जैसा कि नीचे बताया गया है।

Interpreter[#,"AstronomicalObject"]&द्वारा दर्शाए गए शब्द से जुड़ी इकाई (यानी मशीन कम्प्यूटेबल ऑब्जेक्ट) वापस कर देगा #।

EntityValue[AstronomicalObject[],"Radius"]मीलों में, इकाई की त्रिज्या देता है। "ह्यूमिया" के मामले में, 816.27 (यानी 507 * 1.61) मान वापस आ जाता है।

1.61मीलों से किमी में परिवर्तित होकर त्रिज्या का गुणन । पूर्णांक के बजाय दशमलव मान, सबसे चरम मामले में भी, 1% से कम त्रुटि के लिए जिम्मेदार है।

[[1]]इकाई के बिना परिमाण लौटाता है, किमी। बाद में इसे बदल दिया गया #&@@, उसी परिणाम की उपज।

— DavidC
स्रोत
1
एक और वुल्फराम बनाया गया है। जैसे कि डाउनगेट्स का पता लगाना
— ओग्मैन
मैंने इसका उत्तर दिया होगा, लेकिन मुझे
— वुल्फराम
दरअसल, इसके लिए इंटरनेट कनेक्शन भी आवश्यक है (10.2 पर परीक्षण किया गया)
— user202729
@ user202729, आपके अंतिम दो, सहायक, सुझाव अब एकीकृत हैं। खगोलीय संस्थाओं का उपयोग, जैसे कि खगोलीय पिंड, वास्तव में इंटरनेट कनेक्शन की आवश्यकता होती है।
— डेविड डिक
1
उघ, यह त्रिज्या के लिए डिफ़ॉल्ट इकाइयाँ हैं? कम से कम इसमें द्रव्यमान के लिए साने (यानी मीट्रिक) डिफ़ॉल्ट इकाइयाँ हैं ...
— नील
6

पॉवर्सशेल, 150 141 बाइट्स, स्कोर 163 153

($args|% t*y|?{'Su6963J699S582U253N246Ea63V60Ma33G26Ti25Me24C24I18M17Eu15T13P12E12H8Titani8'-cmatch"$(($y+=$_))(\d+)"}|%{100*$Matches.1})[-1]

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

टेस्ट स्क्रिप्ट:

$f = {
($args|% t*y|?{'Su6963J699S582U253N246Ea63V60Ma33G26Ti25Me24C24I18M17Eu15T13P12E12H8Titani8'-cmatch"$(($y+=$_))(\d+)"}|%{100*$Matches.1})[-1]
}

$penalty = @(
    ,("Sun"      , 696342)
    ,("Jupiter"  ,  69911)
    ,("Saturn"   ,  58232)
    ,("Uranus"   ,  25362)
    ,("Neptune"  ,  24622)
    ,("Earth"    ,   6371)
    ,("Venus"    ,   6052)
    ,("Mars"     ,   3390)
    ,("Ganymede" ,   2634)
    ,("Titan"    ,   2575)
    ,("Mercury"  ,   2440)
    ,("Callisto" ,   2410)
    ,("Io"       ,   1822)
    ,("Moon"     ,   1737)
    ,("Europa"   ,   1561)
    ,("Triton"   ,   1353)
    ,("Pluto"    ,   1186)
    ,("Eris"     ,   1163)
    ,("Haumea"   ,    816)
    ,("Titania"  ,    788)
) | % {
    $s,$expected = $_
    $result = &$f $s
    $ratio = [Math]::Max($result/$expected, $expected/$result)
    $ratio*$ratio
}
$scriptLength = $f.ToString().Length - 2  # -4 if CRLF mode
$penaltyMax = ($penalty|Measure-Object -Maximum).Maximum
$score = $scriptLength * $penaltyMax
"$score = $scriptLength * $penaltyMax"

आउटपुट:

152.731283431953 = 141 * 1.08320059171598

स्पष्टीकरण:

  • नामों में केवल अक्षर होते हैं, त्रिज्या में अंक और बिंदु होते हैं। तो हम एक डेटा स्ट्रिंग में सभी डेटा लिख ​​सकते हैं और एक regexp खोज कर सकते हैं।
  • स्क्रिप्ट बाएं से दाएं सभी सबस्ट्रिंग्स को खोजती है और अंतिम परिणाम पाया जाता है।
  • डेटा स्ट्रिंग को कम करने के लिए इनपुट का शीर्षक-केस होना चाहिए।
  • end of line modeवामो ही है।

उदाहरण:

Titania         Triton         Titan
--------------  -------------  -------------
T       -> 1.3  T      -> 1.3  T      -> 1.3
Ti      -> 2.5  Tr     ->      Ti     -> 2.5
Tit     ->      Tri    ->      Tit    ->
Tita    ->      Trit   ->      Tita   ->
Titan   ->      Triton ->      Titan  ->
Titani  -> .8
Titania ->

Result is .8    Result is 1.3  Result is 2.5

Powershell, 178 बाइट्स, स्कोर 178

($args|% t*y|?{'Su696342J69911S58232U25362N24622Ea6371V6052Ma3390G2634Ti2575Me2440C2410I1822M1737Eu1561T1353P1186E1163H816Titani788'-cmatch"$(($y+=$_))(\d+)"}|%{+$Matches.1})[-1]
— Mazzy
स्रोत
4

05AB1E , स्कोर 100 66 60 ( 100 61 56 बाइट्स )

•1∞²îc|I‰∍T‡sÇ3¡ò½в…»Ë•§•1ë£ñƒq£û¿’…•S£y¦¦ÇO96%49%25%èт*

पोर्ट ऑफ @ ओलिवियरग्रेयर के जावा उत्तर , इसलिए यदि आपको यह पहला उत्तर पसंद है, तो उसे भी सुनिश्चित करें!
शीर्षक में इनपुट।

सभी परीक्षण मामलों की जाँच करें।

05AB1E , स्कोर 100 (100 बाइट्स )

•*Òâ%ÌÜS…Ùb‹Úi{e!]ɸ·vÌBUSηHã£āðxyµŠ•§•3«8¹ØмS7Ç•S£.•WùηƵ@,Sº,ûεβʒóÃX\¹Θäáá’Ý)”Ωož∞-z.A±D•3ôI2£Iθ«kè

पूर्ण लोअरकेस में इनपुट। सटीक त्रिज्या आउटपुट करता है, इसलिए कोई जुर्माना नहीं जोड़ा जाता है।

सभी परीक्षण मामलों की जाँच करें।

स्पष्टीकरण:

•*Òâ%ÌÜS…Ùb‹Úi{e!]ɸ·vÌBUSηHã£āðxyµŠ•
                   # Compressed integer 696342699115823225362246226371605233902634257524402410182217371561135311861163816788
 §                 # Casted to string (bug, should have been implicitly..)
  •3«8¹ØмS7Ç•      # Compressed integer 65555444444444444433
   S               # Converted to a list of digits: [6,5,5,5,5,4,4,4,4,4,4,4,4,4,4,4,4,4,3,3]
    £              # The first integer is split into parts of that size: ["696342","69911","58232","25362","24622","6371","6052","3390","2634","2575","2440","2410","1822","1737","1561","1353","1186","1163","816","788"]
     .•WùηƵ@,Sº,ûεβʒóÃX\¹Θäáá’Ý)”Ωož∞-z.A±D•
                   # Compressed string "sunjursanursneeeahvesmasgaetinmeycaoioomoneuatrnploershaatia"
      3ô           # Split into parts of size 3: ["sun","jur","san","urs","nee","eah","ves","mas","gae","tin","mey","cao","ioo","mon","eua","trn","plo","ers","haa","tia"]
        I2£        # The first two characters of the input
           Iθ      # The last character of the input
             «     # Merged together
              k    # Get the index of this string in the list of strings
               è   # And use that index to index into the list of integers
                   # (and output the result implicitly)

मेरा यह 05AB1E टिप देखें (अनुभागों में बड़े पूर्णांक को संपीड़ित करने के लिए कैसे ? और स्ट्रिंग को कैसे शब्दकोश का हिस्सा नहीं संकुचित करना है? ) यह समझने के लिए कि संपीड़न कैसे काम करता है।

मैंने एक 70-बाइट्स विकल्प बनाया जो सूरज को मैप करेगा 600,000; [बृहस्पति, शनि] को 60,000; [यूरेनस, नेपच्यून] को 30,000; [पृथ्वी, वीनस] को 6,000; [मंगल, गैनीमेड, टाइटन, पारा, कैलिस्टो] को 3,000; [io, चंद्रमा, यूरोपा, ट्राइटन, प्लूटो, इरिस] को 1,500; और [हमीआ; टिटानिया] को 750। दुर्भाग्य से यह 117 का स्कोर था। मैं देखूंगा कि क्या मैं बाद में वैकल्पिक दृष्टिकोण के साथ 100 से नीचे आ सकता हूं।

— केविन क्रूज़सेन
स्रोत
1
मुझे एक बेहतर हैश मिला, जो 30-चर एक के बजाय 25-चर स्ट्रिंग का उपयोग करता है। यदि आप इस उत्तर को अद्यतन करना चाहते हैं, तो मेरे जावा उत्तर की जाँच करें;)
— ओलिवियर ग्रेजायर
@ ओलिवियरग्रैगोयर ने सर के लिए धन्यवाद दिया। -6 स्कोर और -7 बाइट्स। :)
— केविन क्रूज़सेन
4

गणितज्ञ, 57 बाइट्स, स्कोर = 62 58

-4 बाइट्स / स्कोर lirtosiast के लिए धन्यवाद !

#&@@WolframAlpha[#<>" size km","Result"]]/._Missing->816&

बस मतलब त्रिज्या के लिए एक वुल्फराम अल्फा खोज करता है।

— LegionMammal978
स्रोत
1
हम्म। क्या यह इंटरनेट का उपयोग करने के रूप में नहीं गिना जाता है? जब तक कि गणितज्ञ वास्तव में पूरे वुल्फरामअल्फा इंजन को शामिल नहीं करते हैं
— ASCII-only
@ ASCII- केवल मेरा मतलब है, गणितज्ञ के डेटासेट की अनुमति है , और WolframAlphaफ़ंक्शन का उपयोग कम से कम चार बार किया गया है ...
— LegionMammal978
हम्म। एक मनमाना निर्णय की तरह थोड़े लगता है, खोज इंजन कार्यों को जोड़ने से अन्य भाषाओं को क्या रोक रहा है? IMO डेटासेट थोड़े अलग होते हैं - उन सभी को डाउनलोड करना इतना भारी होता है कि ज़रूरत पड़ने पर एक केंद्रीय सर्वर इसे आपको दे देता है
— ASCII-only
@ ASCII- केवल यदि आप चिंतित हैं, तो आप हमेशा मेटा पर एक प्रश्न पोस्ट कर सकते हैं।
— लीजियनममाल 978
@ उस स्थिति में डेटा को डाउनलोड करने के बाद ऑफ़लाइन उपयोग किया जा सकता है। इस मामले में, यह नहीं है।
— user202729
4

जेली , 28 बाइट्स, स्कोर = 31

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥ1.1*

यह एक विन्यास योग्य हैशिंग बिल्ट-इन का उपयोग करता है जो मैंने @ lirtosiast के सुझाव पर जेली में जोड़ा था।

इनपुट शीर्षक में है, आउटपुट 1.1 की शक्ति है जिसमें कम से कम त्रुटि है।

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

यह काम किस प्रकार करता है

इस उत्तर में केवल दो भाग होते हैं।

  • सबसे पहले, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥ20 अलग-अलग पूर्णांकों के लिए 20 संभावित इनपुट में से प्रत्येक को मैप करने के लिए नए बिल्ट-इन का उपयोग करता है।
  • फिर, 1.1*गणना शक्ति को 1.1 बढ़ा देता है।

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘[95,95,169,55,242],[82,85,117,141,78,77,92,115,79,83,74,106,91,70,76]

ḥ[95,95,169,55,242]1376510639244 ।

0[376510639244,188255319622,94127659811,47063829905,...,5,2,1,0][188255319622,94127659811,47063829906,...,3,1,1] ।

अगला, हम 64 64-बिट पूर्णांक को SHAKE256-4096 के आंतरिक प्रतिनिधित्व के ḥसही प्रतिनिधित्व के स्ट्रिंग प्रतिनिधित्व पर लागू करके उत्पन्न करते हैं , फिर परिणामी 4096 बिट्स को 64 64-बिट विखंडन में काटते हैं।

ḥ264[0,264)

[82,85,117,141,78,77,92,115,79,83,74,106,91,70,76][0,15)

उपयुक्त हैश विन्यास को खोजने के लिए, मैंने C में एक ब्रूट-फोरसर का उपयोग किया है जो कि जेली रेपो का एक हिस्सा है ।

— डेनिस
स्रोत
3

पायथन 2 , 155 बाइट्स, स्कोर = 155

lambda p:int('G11KK54222111111XXNM8MCO37WQ53YXHE93V8BIF2IMH1WU9KPU2MLN    HGR'['uSJJaSrUNNrEnVsMeGtTMMoCoInMuErTuPsEaHTT'.find(p[7%len(p)]+p[0])/2::20],35)

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

आश्चर्यजनक रूप से इस आलसी समाधान के लिए ... के रूप में अच्छी तरह से सुधार में दिखेगा। ;-)

— आउटगोल्फर को एरिक करें
स्रोत
3

जाप , 86 बाइट्स, स्कोर = 94

g5 ¥'i?788:[7*A³7*L6*LG²G²IIÉHÄDÑDÑCÑCÑGÄÄGÄGECC8]g`suj«a¨Ì¼và@ã/eÖô¶e©rp¤r`bU¯2)z)*L

सभी इनपुट्स के लिए इसे आज़माएं , स्कोर की गणना करें या उच्चतम त्रुटि की जांच करें

ओलिवियर के मूल उत्तर के समान। इनपुट सभी लोअरकेस है।

आउटपुट मानों में विभिन्न सुधारों के बाद, वर्तमान उच्चतम त्रुटि केवल 4% से अधिक है।

अब स्पष्टीकरण है कि चीजें थोड़ी अधिक स्थिर हैं:

¤¥`Éa`?                             :If the fifth character of the input is 'i':
       788                          : Output 788.
          :                         :Otherwise:
           [...]                    : From the array representing radii
                g                   : Get the value at the index:
                 `...`              :  In the string representing names
                      b             :  Find the first index where this string appears:
                       U¯2)         :   The first two characters of the input
                           z)       :  And divide it by two
                             *L     : Multiply that value by 100

नामों के लिए स्ट्रिंग को sujusaurneeavemagatimecaiomoeutrplerhaJapt की अंतर्निहित संपीड़न का उपयोग करके संपीड़ित किया जाता है। त्रिज्या का प्रतिनिधित्व करने वाले संख्याओं की गणना इस प्रकार की जाती है:

                          My value | Actual value
                          ---------+-------------
7 * 10 ^ 3 = 7000 * 100 =   700000 | 696342
7 * 100    = 700  * 100 =    70000 |  69911
6 * 100    = 600  * 100 =    60000 |  58232
16 * 16    = 256  * 100 =    25600 |  25362
16 * 16    = 256  * 100 =    25600 |  24622
64         = 64   * 100 =     6400 |   6371
64 - 1     = 63   * 100 =     6300 |   6052
32 + 1     = 33   * 100 =     3300 |   3390
13 * 2     = 26   * 100 =     2600 |   2634
13 * 2     = 26   * 100 =     2600 |   2575
12 * 2     = 24   * 100 =     2400 |   2440
12 * 2     = 24   * 100 =     2400 |   2410
16 + 1 + 1 = 18   * 100 =     1800 |   1822
16 + 1     = 17   * 100 =     1700 |   1737
16         = 16   * 100 =     1600 |   1561
14         = 14   * 100 =     1400 |   1353
12         = 12   * 100 =     1200 |   1186
12         = 12   * 100 =     1200 |   1163
8          = 8    * 100 =      800 |    816
788                     =      788 |    788
— कामिल दकरी
स्रोत
3

जाप, 77 76 75 बाइट, स्कोर = 75

इस पर पहले पास; मैं अपने आप को काम करने के लिए एक आधार रेखा देने के लिए 0 दंड समाधान की कोशिश करना चाहता था। कल यह देखने के लिए वापस आएगा कि क्या सुधार किए जा सकते हैं, उम्मीद है कि अभी भी 0 दंड के लिए।

इनपुट केस-असंवेदनशील है।

n35 %87%52 g"..."ò)mc

यह कोशिश करो या सभी आदानों का परीक्षण करें

"..."एक स्ट्रिंग कई unprintables युक्त प्रतिनिधित्व करता है। कोडपॉइंट हैं:

32,32,15,61,11,86,696,342,25,75,699,11,33,90,63,71,24,10,24,40,253,62,60,52,32,32,8,16,11,63,32,32,32,32,58,232,17,37,135,3,246,22,18,22,26,34,7,88

एक त्वरित व्याख्या प्रदान करने के लिए: स्ट्रिंग 2 वर्णों के टुकड़ों में विभाजित हो जाती है। फिर हम ओव्स फॉर्मूला और कुछ इंडेक्स-रैपिंग के हिस्से का उपयोग करके उस एरे में इंडेक्स करते हैं और फिर 2 कैरेक्टर को उनके कोडपॉइंट पर मैप करते हैं।

  • ETH के लिए एक बाइट / बिंदु धन्यवाद सहेजा गया

54 बाइट्स, स्कोर = 58

ओलिवियर के समाधान का एक बंदरगाह ।

"ýCĄ (ᬺ!˂Fɍ"cU¤¬xc %96%49)-7 *L

सभी इनपुट का परीक्षण करें

— झबरा
स्रोत
मुझे लगता है कि आप पहली प्रविष्टि (# 23) को अंत तक ले जाकर एक बाइट को बचा सकते हैं, जहाँ यह है, और %24:-) हटाना
— ETHproductions
— Shaggy
— ETHproductions
@ETHproductions: आह, हाँ, बस खुद को घुमाया है कि मुझे सरणी की शुरुआत में एक प्लेसहोल्डर तत्व जोड़ना होगा। धन्यवाद।
— शैगी
3

रूबी , 105 बाइट्स, स्कोर 109

->n{7E5/('!)"0 r&zZ&1#}3Mfh-~~d@'[0,j=" =1&%)AM<I>2,-B#($D  7@".index((n[1,9].sum%50+34).chr)].sum-j*32)}

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

यदि हम we००००० को रेडी से विभाजित करते हैं, तो हमें एक अनुक्रम मिलता है जो यथोचित रैखिक रूप से बढ़ता है (हालांकि गलत तरीके से)। नीचे दी गई तालिका में वेतन वृद्धि को ASCII वर्णों के मान द्वारा अनुमानित किया जा सकता है। इस दृष्टिकोण के साथ समस्या यह है कि इनपुट को एक मूल्य पर डिकोड किया जाना चाहिए जो आकार द्वारा विभिन्न नामों का आदेश देता है।

एक छोटी सी बात यह है कि एरिस और ह्यूमिया के बीच का अंतर काफी बड़ा है। ~~dASCII में केवल प्रारूप में इस वेतन वृद्धि को कूटबद्ध करने के लिए तीन वर्णों की आवश्यकता होती है। इंडेक्स को पैड करने के लिए ग्रह-टू-इंडेक्स स्ट्रिंग में दो "भूत ग्रह" स्थान हैं।

700000/r    increment from previous
0.994774    
9.960407    8.965633
11.95806    1.997657
27.45612    15.49805
28.28129    0.825178
109.2987    81.0174
115.0598    5.761118
205.4106    90.3508
264.3667    58.95612
270.4241    6.057335
285.3861    14.96199
288.9386    3.552524
382.1855    93.24692
400.8877    18.70223
446.0871    45.19939
514.6652    68.57806
587.1349    72.46972
598.7463    11.61144
853.3603    254.6139
883.6827    30.32245
— स्तर नदी सेंट
स्रोत
3

टी-एसक्यूएल, 203 202 201 196 बाइट्स, स्कोर = 217 216 212 208

SELECT IIF(v='Titan',13,STUFF(value,1,2,''))*198
FROM i,STRING_SPLIT('Ca12,Ea32,Er6,Eu8,Ga13,Ha4,Io9,Ju353,Ma17,Me12,Mo9,Ne124,Pl6,Sa294,Su3517,Ti4,Tr7,Ur128,Ve31',',')
WHERE LEFT(v,2)=LEFT(value,2)

लाइन ब्रेक केवल पठनीयता के लिए हैं।

इनपुट को पूर्व-मौजूदा तालिका I के माध्यम से varchar कॉलम v , हमारे IO मानकों के अनुसार लिया जाता है ।

पहले दो वर्णों पर एक इन-मेमोरी टेबल में इनपुट तालिका से जुड़ता है, और शेष अंक x100 को वापस करता है।

"टाइटन" का उपयोग एक विशेष मामले के रूप में करता है IIF।

संपादित करें : STUFFइसके बजाय पहले दो वर्णों को मिटाने के लिए 1 बाइट (और 1 अंक) की बचत की SUBSTRING। धन्यवाद, t-clausen.dk!

संपादित करें 2 : मैं देखना चाहता था कि क्या होगा यदि मैंने 100 के बजाय प्रत्येक लुकअप मान को 99 बाइट से गुणा करके एक और बाइट को बचाने की कोशिश की, और मुझे आश्चर्य हुआ कि यह वास्तव में बढ़ गया है में सटीकता (कम से कम सटीक अनुमान) है!।

इसने मुझे कुछ परीक्षण और त्रुटि परीक्षण के लिए प्रेरित किया, और कुछ फैंसी एक्सेल क्या-क्या डेटा तालिकाओं, जहां मुझे 89 के एक बहु-स्तरीय का उपयोग करके एक इष्टतम समाधान मिला। (जो निश्चित रूप से मेरे सभी संग्रहीत मूल्यों को बदल दिया)।

तो जबकि यह मुझे केवल एक बाइट बचाता है, यह वास्तव में मेरे पूर्व समाधान से मेरे स्कोर में 4.6 सुधार करता है ।

EDIT 3 : निम्न के बजाय उच्चतर खोजा, और एक बेहतर गुणन कारक, 198 पाया । मान काफी संचित रहते हुए मेरे संचित स्ट्रिंग को काफी कम वर्णों से छोटा करते हैं, जिससे मेरा स्कोर बेहतर हो जाता है।

— BradC
स्रोत
1
आप
— प्रतिस्थापन के
2

पॉवरशेल , 203 बाइट्स, स्कोर 203

param($a)if($a-eq'Titan'){2575;exit}(696342,69911,58232,25362,24622,6371,6052,3390,2634,2440,2410,1822,1737,1561,1353,1186,1163,816,788)["SuJuSaUrNeEaVeMaGaMeCaIoMoEuTrPlErHaTi".indexOf(-join$a[0..1])/2]

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

ओलिवियर के उत्तर के समान, अब जब कि मैं इसे देखता हूं, लेकिन स्वतंत्र रूप से विकसित हुआ।

— AdmBorkBork
स्रोत
1

चारकोल , 101 बाइट्स, स्कोर = 101

Ｉ⍘§⪪“_″FJ⁼⦄b\l≕)Ｔ‹#⊙xO-nη⁻À↓ζ↥ς§%Ｈ8H“ρj✳Hρl× S↶…|ＵＤ⎇ＬkfZ”³⌕⪪”@/rjmq_↙§Ｅ▶νＦ↨oº⁷÷Ｋ⁻eDH:_Tbk¦�”²⁺§θ⁰§θχγ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

⁺§θ⁰§θχ

इनपुट स्ट्रिंग के 1 और 11 वें चरित्र (चक्रीय रूप से) को लें और उन्हें समतल करें।

⌕⪪”@/rjmq_↙§Ｅ▶νＦ↨oº⁷÷Ｋ⁻eDH:_Tbk¦�”²

उन्हें SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTaपात्रों के जोड़े में विभाजित स्ट्रिंग में देखें।

§⪪“_″FJ⁼⦄b\l≕)Ｔ‹#⊙xO-nη⁻À↓ζ↥ς§%Ｈ8H“ρj✳Hρl× S↶…|ＵＤ⎇ＬkfZ”³

स्ट्रिंग m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<को तीन वर्णों के समूहों में विभाजित करें और संबंधित समूह लें।

Ｉ⍘ ... γ

अंकों के रूप में सेट करने योग्य मुद्रण योग्य ASCII वर्ण का उपयोग करके परिणाम को आधार -95 संख्या के रूप में घोषित करें। उदाहरण: Io11 वां वर्ण है I, इसलिए हम देखते हैं IIऔर पाते हैं कि यह 13 वीं सबसे बड़ी वस्तु है और इसका आकार 31किन मानचित्रों के लिए है 19 * 95 + 17 = 1822।

— नील
स्रोत
1

स्विफ्ट 4 , 225 बाइट्स, स्कोर = 241

संभवतः गोल्फ का एक गुच्छा अधिक (शायद "गा-मी-सीए" क्षेत्र में?), लेकिन स्विफ्ट का उपयोग अक्सर नहीं किया जाता है (एक कारण के लिए, शायद।)

func b(i:String){print(i=="Titan" ?2575:["Su":6963,"Ju":699,"Sa":582,"Ur":253,"Ne":246,"Ea":63,"Ve":60,"Ma":33,"Ga":26,"Me":24,"Ca":24,"Io":18,"Mo":17,"Eu":16,"Tr":14,"Pl":12,"Er":12,"Ha":8,"Ti":8][String(i.prefix(2))]!*100)}

और अपुष्ट

func size(ofAstralObject object: String) {
  let objectToRadius = // Map size/100 of all objects to the first two chars
   ["Su":6963,
    "Ju":699,
    "Sa":582,
    "Ur":253,
    "Ne":246,
    "Ea":63,
    "Ve":60,
    "Ma":33,
    "Ga":26,
    "Me":24,
    "Ca":24,
    "Io":18,
    "Mo":17,
    "Eu":16,
    "Tr":14,
    "Pl":12,
    "Er":12,
    "Ha":8,
    "Ti":8] // Ti is Titania, while Titan is treated differently

  print(object == "Titan" ? 
    2575 : // If "Titan", print the exact size
    objectToRadius[String(i.prefix(2))]!*100 // get the size from the map and multiply by 100
  )
}

यह ऑनलाइन की कोशिश करो!

मैंने मानचित्र के लिए अलग-अलग "प्रमुख आकारों" की कोशिश की, लेकिन निश्चित रूप से 1 में कई झड़पें हैं और तीन वर्णों का उपयोग करने से मुझे i=="Titan" ?2575:17 वर्ण नहीं मिलते हैं, क्योंकि प्रबंधन करने के लिए "Io" है (और यह 3 चार्ट से अधिक ले जाएगा) मुझे लगता है)।

— सिमोन चेलो
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 152 बाइट्स, स्कोर = 163

खैर, यह एक सुंदर मानक समाधान है, लेकिन मैंने वैसे भी चुनौती का आनंद लिया!

s=>s=='Titan'?2575:[6963,699,582,254,246,64,60,34,26,24,24,18,17,16,14,12,12,8,8]["SuJuSaUrNeEaVeMaGaMeCaIoMoEuTrPlErHaTi".match(s[0]+s[1]).index/2]*100

मेरा स्कोर:

Max. penalty ratio = 1.07068 for Triton
Score = ceil(152 x 1.07068) = 163

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

— zruF
स्रोत
1

FALSE , 152 बाइट्स, स्कोर = 563

[911*.]^$0\[~][1+^]#$$2=\$4=\8=||[2 0!]?$3=[764 0!]?$5=[\$$69=\86=|$[6\]?~[2]?0!]?$6=[\$$83=\85=|$[46\]?~[$72=$[1\]?~[2]?]?0!]?$7=[\$84=$[1\]?~[52]?0!]?

शब्द लंबाई और पहले अक्षरों का उपयोग करके आलसी उत्तर लेकिन मेरा बहाना यह है कि मैं एक अजीब भाषा का उपयोग कर रहा हूं

इसे ऑनलाइन आज़माएं! (कॉपी पेस्ट कोड, हिट शो और फिर चलाएं)

[911*.]          {defines a function that multiplies a number by 911 and then prints it}
^$0\[~][1+^]#    {counts the length of the name as it's input, also records the first char}
$$2=\$4=\8=||[1 0!]?  {if the name is 2, 4, or 8 chars long print 911*2 (0! calls the function)}
$3=[764 0!]?          {if name is 3 long print 911*764}
$5=[\$$69=\86=|$[6\]?~[2]?0!]? {5 long? print 911*6 if it starts with E or V, otherwise *2}
$6=[\$$83=\85=|$[46\]?~[       {6 long? print 911*46 if it starts with S or U, otherwise:}
    $72=$[1\]?~[2]?            {if name starts with H print 911*1 else *2
]?0!]?
$7=[\$84=$[1\]?~[26]?0!]?      {7 long? print 1822*1 if it starts with NT otherwise *26 (for jupiter}

मेरे परिणाम:

Sun       : 696004.00 penalty ratio = (696342.00 / 696004.00 )² = 1.00097
Jupiter   : 47372.00  penalty ratio = (69911.00  / 47372.00  )² = 2.17795
Saturn    : 41906.00  penalty ratio = (58232.00  / 41906.00  )² = 1.93095
Uranus    : 41906.00  penalty ratio = (41906.00  / 25362.00  )² = 2.73014
Neptune   : 47372.00  penalty ratio = (47372.00  / 24622.00  )² = 3.70166
Earth     : 5466.00   penalty ratio = (6371.00   / 5466.00   )² = 1.35855
Venus     : 5466.00   penalty ratio = (6052.00   / 5466.00   )² = 1.22591
Mars      : 1822.00   penalty ratio = (3390.00   / 1822.00   )² = 3.46181
Ganymede  : 1822.00   penalty ratio = (2634.00   / 1822.00   )² = 2.08994
Titan     : 1822.00   penalty ratio = (2575.00   / 1822.00   )² = 1.99737
Mercury   : 1822.00   penalty ratio = (2440.00   / 1822.00   )² = 1.79342
Callisto  : 1822.00   penalty ratio = (2410.00   / 1822.00   )² = 1.74959
Io        : 1822.00   penalty ratio = (1822.00   / 1822.00   )² = 1.00000
Moon      : 1822.00   penalty ratio = (1822.00   / 1737.00   )² = 1.10026
Europa    : 1822.00   penalty ratio = (1822.00   / 1561.00   )² = 1.36236
Triton    : 1822.00   penalty ratio = (1822.00   / 1353.00   )² = 1.81343
Pluto     : 1822.00   penalty ratio = (1822.00   / 1186.00   )² = 2.36008
Eris      : 1822.00   penalty ratio = (1822.00   / 1163.00   )² = 2.45435
Haumea    : 911.00    penalty ratio = (911.00    / 816.00    )² = 1.24640
Titania   : 911.00    penalty ratio = (911.00    / 788.00    )² = 1.33655

Max. penalty ratio = 3.70166 for Neptune
Score = ceil(152 x 3.70166) = 563
— Terjerber
स्रोत
1634
मैंने इसे 1822 (911) के आधे हिस्से का उपयोग करने के लिए अद्यतन किया, इसके बजाय मैं हौमिया के लिए एक विशेष मामला बना सकता था, इसलिए यह सलाह अब काम नहीं करती है। मैंने 817 (1634 का आधा) का उपयोग करने की कोशिश की, लेकिन यह अच्छा नहीं था। यदि आप अपने जादू को काम करना चाहते हैं और नया सबसे इष्टतम नंबर महसूस करना चाहते हैं।
— Terjerber
1

सी (जीसीसी) , 118 बाइट्स, स्कोर = 135

i;f(char*s){i=exp((strchr("(~?_q#m#.(`(=*2,r-v.h2z2p3d3j6>Qb>a?{Qx]",(*s^s[1]*4)+(strlen(s)!=5)&127|32)[1]+55)/13.5);}

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

स्कोरिंग

मंद होना

ऑब्जेक्ट नाम को बोझिल प्रक्रिया के माध्यम से एकल-वर्ण हैश में बदल दिया गया है

(((*s ^ s[1] << 2) + (strlen(s) != 5)) & 127) | 32

जिसका ब्लोट मुख्य अपराधियों के रूप में "टाइटन" / "टाइटेनिया" को इंगित करता है। हैश में अंतिम चरित्र को शामिल करने पर विचार किया गया था, लेकिन अभी भी एक की आवश्यकता हैstrlen() सी में । हैश चरित्र की पहली घटना हैश / डेटा स्ट्रिंग में खोजी गई है। जब पाया जाता है, तो अगले चरित्र को लिया जाता है और प्रश्न में वस्तु की त्रिज्या का अनुमान लगाया जाता है।

डेटा वर्ण त्रिज्या के स्थानांतरित, स्केल किए गए प्राकृतिक लघुगणक को धारण करता है। इस तरह उत्पन्न:

for (int i = 0; i < 20; i++)
    data[i] = log(radii[i]) * 13.5 - 55;

पैमाने को अत्यधिक वैज्ञानिक परीक्षण-और-त्रुटि के माध्यम से चुना गया था, और बैकलैश से बचने के दौरान प्रिंट करने योग्य ASCII रेंज के भीतर मूल्य लाने के लिए बदलाव। कुछ हैश / डेटा टकराव के कारण स्ट्रिंग में वस्तुओं का कुछ पुनर्व्यवस्था आवश्यक था।

i;                                      Return value
f(char*s){                              s is object name
    i=                                  Implicit return
    exp(                                Raise e to some power
        (
            strchr(                     Find hash
                "...",                  Hash/data string
                (*s^s[1]*4)+            Calculate...
                (strlen(s)!=5)&127|32   ...hash
            )
            [1]                         Char following hash holds the power
            +55                         Shift it
        )/13.5                          Scale it
    );                                  Use it
}                                       Exit
— gastropner
स्रोत
0

पायथन 2 , 89 बाइट्स, स्कोर = 234

lambda(p):39**4/'zzuSJJaSrUNNrEnVsMeGtTMMoCoInMuErTuPsEaHTT'.find(p[7%len(p)]+p[0])**2.18

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

पोस्ट किए गए अधिकांश उत्तर "एन्कोड / डिकोड" रणनीति का उपयोग करते हैं। मैंने सोचा कि मैं एक साधारण समीकरण का उपयोग करके आकाशीय पिंडों के व्यास का अनुमान लगाकर कितना अच्छा कर सकता हूं। यह एक मजेदार अभ्यास रहा है, लेकिन मध्यम बाइट की बचत सटीकता के दंड से अधिक है।

इस समाधान का मूल आकलन समीकरण है:

Radius = 39**4/x**2.18

जहाँ x शरीर के त्रिज्या के क्रम का दोगुना है।

मैं इनपुट स्ट्रिंग के आधार पर x का मान @ आउट्रिकोलर के पायथन 2 समाधान के संशोधन का उपयोग करके उत्पन्न करता हूं। मैंने [1..20] के बजाय [2..40] के साथ काम करने के लिए अपने समीकरणों को फिर से पढ़कर उनके कोड पर कुछ बाइट्स बचाए।

रैंक ऑर्डर तैयार करने के लिए कोड पूरे समाधान के बाइट्स के 2/3 से अधिक लेता है। यदि किसी के पास रैंकों को उत्पन्न करने का अधिक कॉम्पैक्ट तरीका है, तो इस समाधान को और छोटा किया जा सकता है। सटीकता दंड (2.6 के आसपास) के कारण, स्कोर में थोड़ा सुधार होगा।

समीकरण बनाना

मैंने अपने रैंक के आधार पर प्रत्येक शरीर के आकार का अनुमान लगाने के लिए सरल समीकरणों की खोज करने के लिए सांख्यिकीय विधियों का उपयोग किया। भाग में @Level नदी सेंट के रूबी समाधान और सामान्यीकरण में अंतर्दृष्टि पर, मैं फार्म के समीकरणों पर बसे:

Radius = A/(Rank)**B

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

उपरोक्त समीकरण में ए का अनुमानित मूल्य सात अंक है, इसलिए मैंने एक सरल अभिव्यक्ति के लिए कुछ बाइट्स को बचाने के लिए खोज की। मैंने फॉर्म के भावों की तलाश की

x**y

दो अंकों की x और 1 अंकों की y के लिए (कुल पाँच बाइट्स के लिए, दो बाइट्स बचाने के लिए, या पाँच बिंदुओं के बारे में, जुर्माना दिया गया) जो कि A के इष्टतम मूल्य से बहुत अलग नहीं था और जुर्माना को अधिक नहीं बढ़ाता था, और समाप्त हो गया (अन्यथा अकथनीय) के साथ:

39**4
— CCB60
स्रोत
स्कोरिंग एल्गोरिदम वास्तव में इस पद्धति को चोट पहुंचाता है - मुझे लगता है कि यह L2 या L1 त्रुटि के मानक के तहत बेहतर करेगा। हालांकि आप वैसे भी नामों को संग्रहित करके बाइट बर्बाद कर रहे हैं।
— lirtosiast
@lirtosiast दोनों बिंदुओं पर सहमत हैं। दिलचस्प बात यह है कि इस स्कोरिंग एल्गोरिदम के तहत एक न्यूनतम वर्ग फिट (एल 2 मानक) बहुत अच्छा है। मैंने जो सबसे अच्छा समीकरण पाया है, उससे लगभग 5% बदतर जुर्माना है। नामों को संग्रहीत करने पर: मैं पाठ इनपुट से संख्याओं के बढ़ते क्रम को उत्पन्न करने के लिए अधिक कॉम्पैक्ट तरीके का पता नहीं लगा सका। अन्य उत्तरों में लिए गए मोडुलो अंकगणितीय दृष्टिकोण क्रम को यादृच्छिक बनाते हैं।
— CCB60
0

TI-BASIC (TI-84), 285 बाइट्स, स्कोर = 285

Ans→Str1:{696342,69911,58232,25362,24622,6371,6052,3390,2634,2575,2440,2410,1822,1737,1561,1353,1186,1163,816,788:Ans(-int(-.125inString("SUN     JUPITER SATURN  URANUS  NEPTUNE EARTH   VENUS   MARS    GANYMEDETITAN   MERCURY CALLISTOIO      MOON    EUROPA  TRITON  PLUTO   ERIS    HAUMEA  TITANIA",Str1

एक सरल "सूची में स्ट्रिंग में सूचकांक" कार्यक्रम। आगे गोल्फ हो सकता है।

इनपुट Ansपूर्ण अपरकेस में ऑब्जेक्ट्स के नाम में से एक है।
आउटपुट में है Ansऔर स्वचालित रूप से प्रिंट आउट है।

उदाहरण:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

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

Ans→Str1:{696342,69911,5...:Ans(-int(-.125inString("SUN     JU...",Str1  ;complete source

Ans→Str1                                                                 ;store the input string
                                                                         ; in "Str1"
         {696342,69911,5...                                              ;generate the list of
                                                                         ; radii and leave it in
                                                                         ; "Ans"
                                          inString("SUM     JU...",Str1  ;get the index of the
                                                                         ; input string in the
                                                                         ; name string
                                      .125                               ;multiply the index by 1/8
                                -int(-                                   ;then round it towards
                                                                         ; positive infinity
                            Ans(                                         ;use the result as the
                                                                         ; index of the radii list

दृश्य मॉडल:

Ans→Str1                                            ;Ans = "MOON"
                                                    ;Str1 = "MOON"

{696342,69911,5...                                  ;Ans = {696232 69911 ... }
                                                    ;Str1 = "MOON"

inString("SUN      JU...",Str1                      ;Ans = {696232 69911 ... }
                                                    ;Str1 = "MOON"
                                                    ;current evaluation: 105

.125                                                ;Ans = {696232 69911 ... }
                                                    ;current evaluation: 13.125

-int(-                                              ;Ans = {696232 69911 ... }
                                                    ;current evaluation: 14

Ans(                                                ;Ans = 1737
— ताउ
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.