คุณจะได้รับชื่อหนึ่งใน 20 วัตถุที่ใหญ่ที่สุดในระบบสุริยะ งานของคุณคือการคืนค่าประมาณรัศมีของมันแสดงเป็นกิโลเมตร

นี่คือความท้าทายของรหัสที่คะแนนของคุณประกอบด้วยความยาวของรหัสของคุณ (เป็นไบต์) คูณด้วยอัตราการลงโทษ$\ge 1$ขึ้นอยู่กับการประมาณที่เลวร้ายที่สุดของคุณ ดังนั้นคะแนนต่ำสุดชนะ

_{"ในขณะที่เราเดินทางจักรวาล" เป็นบรรทัดสุดท้ายของเพลงดาวเคราะห์คาราวานโดย Black Sabbath , หลังจากนั้นก็ปกคลุมด้วย Pantera}

วัตถุระบบสุริยะ

ที่มา: Wikipedia

หมายเหตุ: อันดับจะได้รับข้อมูลเท่านั้น อินพุตเป็นชื่อของวัตถุ

  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

คะแนนของคุณ

ให้$R_n$เป็นรัศมีที่คาดหวังของวัตถุ$n^{th}$และปล่อยให้$A_n$เป็นคำตอบของโปรแกรมของคุณสำหรับวัตถุนี้

จากนั้นคะแนนของคุณจะถูกกำหนดเป็น:

โดยที่คือความยาวของโค้ดของคุณเป็นไบต์$L$

ตัวอย่าง:

หากขนาดของรหัสของคุณคือไบต์และการประมาณที่เลวร้ายที่สุดของคุณอยู่บนดวงจันทร์โดยมีรัศมีประมาณกม. แทนที่จะเป็นกม. คะแนนของคุณจะเป็น:$100$$1000$$1737$

ยิ่งต่ำยิ่งดี

ส่วนหัวที่แนะนำสำหรับคำตอบของคุณ:

Language, 100 bytes, score = 302

คุณสามารถใช้สคริปต์นี้เพื่อคำนวณคะแนนของคุณ (บรรทัดแรก = ความยาวโค้ด, 20 บรรทัดถัดไป = ผลลัพธ์ของคุณจากซันถึงไททาเนีย)

กฎระเบียบ

• คุณอาจใช้ชื่อของวัตถุในตัวพิมพ์เล็กเต็มทั้งตัวพิมพ์ใหญ่เต็มรูปแบบหรือตรงตามที่อธิบายไว้ข้างต้น (กรณีชื่อ) ไม่อนุญาตให้ใช้กรณีผสมอื่น ๆ
• อินพุตถูกรับประกันว่าเป็นหนึ่งใน 20 ชื่อที่เป็นไปได้
• คุณอาจกลับจำนวนเต็มหรือลอย ในทั้งสองกรณีการลงโทษจะต้องคำนวณโดยตรงกับค่าเหล่านี้ (ไม่ใช่ค่าที่ปัดเศษในกรณีที่มีการลอย)
• คุณต้องส่งคืนค่าบวก
• ไม่อนุญาตให้ใช้โปรแกรมเปล่า

PowerShellขนาด 3 ไบต์คะแนน3637

2e4

ลองออนไลน์!

ไร้เดียงสาน่าเบื่อการนำไปปฏิบัติ; เพียงแค่ส่งกลับ20000ไม่ว่าอินพุต การทดลองกับสิ่งต่าง ๆ เช่นการบรรจุดวงอาทิตย์เป็นพิเศษหรือการใช้ค่าจุดลอยตัวแทนที่จะ2ส่งผลให้คะแนนแย่ลงเพราะความยาวของรหัสเพิ่มขึ้นมากพอที่จะชดเชยผลกำไรที่ได้จากการเปรียบเทียบขนาด

เยลลี่ , 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

Java (JDK) , 90 ไบต์, คะแนน = 97

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

ลองออนไลน์!

• รายการนี้ใช้อักขระ Unicode undisplayable และหลายไบต์ (แต่ Java ยอมรับได้) ตรวจสอบรหัส TIO ที่ถูกต้อง
• อินพุตจะต้องเป็นชื่อเรื่องตัวพิมพ์เล็ก
• รหัสนี้จะปัดเศษของค่าเป็นผลคูณของ 100 ที่ดีที่สุด (บางครั้งขึ้นหรือลงบางครั้ง) เพื่อให้สามารถข้ามตัวเลขสองหลักสุดท้ายเมื่อมีการเข้ารหัสและค่านั้นสามารถประมาณด้วยการคูณด้วย 100
• รายการนี้ใช้แฮชต่าง ๆ เพื่อให้พอดีกับสตริง codepoints 25 ตัว (สตริงที่สั้นที่สุดที่ฉันสามารถหาได้)

เครดิต

• -48 คะแนน (-45 bytes) ต้องขอบคุณKevin Cruijssenโดยการเข้ารหัสรัศมี (หารด้วย 100) โดยตรงStringแทนการเข้ารหัสด้วยhardcoding ในintอาเรย์ที่ชัดเจน..

ภาษา Wolfram 114 103 97 88 86 82 ไบต์ คะแนน = 114 103 97 89 87 83 คะแนน

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

อย่างน้อย 6 จุดที่บันทึกไว้ขอบคุณที่Dennisมากขึ้นหลายขอบคุณที่lirtosiast6 user202729และขอบคุณมากขึ้นเพื่อ

แม้ว่า Mathematica สามารถดึงข้อมูลระบบสุริยะ (เช่นเดียวกับข้อมูลทางดาราศาสตร์อื่น ๆ อีกมากมาย) จำเป็นต้องมีการปรับแต่งเล็กน้อยตามที่อธิบายไว้ด้านล่าง

Interpreter[#,"AstronomicalObject"]&จะกลับนิติบุคคล (เช่นวัตถุคำนวณเครื่อง) #ที่เกี่ยวข้องกับคำที่แสดงโดย

EntityValue[AstronomicalObject[],"Radius"]ส่งคืนรัศมีเป็นไมล์ของเอนทิตี ในกรณีของ "Haumea" จะส่งคืนค่า 816.27 (เช่น 507 * 1.61)

การคูณรัศมีด้วยการ1.61แปลงจากไมล์เป็นกิโลเมตร ค่าทศนิยมแทนที่จะเป็นจำนวนเต็มคิดเป็นข้อผิดพลาดน้อยกว่า 1% แม้ในกรณีที่รุนแรงที่สุด

[[1]]ส่งคืนขนาดโดยไม่มีหน่วยเป็น km สิ่งนี้ถูกเปลี่ยนเป็นภายหลัง#&@@โดยให้ผลลัพธ์เหมือนกัน

Python 3คะแนน 95, 95 ไบต์

lambda n:ord("ؙҢ򪀖ਏ𑄗ാᣣ४ঈ挒ឤ?̰ҋ??ۉՉ怮ܞ੊̔"[int(n,35)%87%52%24-1])

ลองออนไลน์!

Python 3 , คะแนน 133, 133 ไบต์

lambda n:int(f'00e0{10**18+10**6}10x1h2411j4?00??811i1207wazxmwuvko?mw??xc1ze1ldyujz6zysi4?ob??k9lym6w'[int(n,35)%87%52%24-1::23],36)

ลองออนไลน์!

Powershell, 150 141 bytes, คะแนน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เป็น LF เท่านั้น

ตัวอย่าง:

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]

05AB1Eคะแนน100 66 60 ( 100 61 56 ไบต์ )

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

คำตอบ Javaของ Port of @ OlivierGrégoireดังนั้นหากคุณชอบคำตอบแรกนี้อย่าลืมโหวตให้ดีเช่นกัน!
ใส่ในหัวเรื่อง

ตรวจสอบกรณีทดสอบทั้งหมด

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 ไบต์ซึ่งจะ map แดด600,000; [ดาวพฤหัสบดี, ดาวเสาร์] ถึง60,000; [ดาวยูเรนัสดาวเนปจูน] ถึง30,000; [โลกวีนัส] ถึง6,000; [mars, ganymede, titan, mercury, callisto] ถึง3,000; [io, ดวงจันทร์, europa, triton, ดาวพลูโต, eris] ถึง1,500; และ [Haumea; Titania] 750เพื่อ น่าเสียดายที่มีคะแนน 117 ฉันจะดูว่าฉันจะได้ต่ำกว่า 100 ด้วยวิธีการอื่นในภายหลัง

Mathematica, 57 ไบต์, คะแนน = 62 58

^{-4 ไบต์ / คะแนนขอบคุณlirtosiast !}

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

ทำการค้นหา Wolfram Alpha เพื่อหาค่าเฉลี่ยรัศมี

เยลลี่ , 28 ไบต์, คะแนน = 31

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

สิ่งนี้ใช้การแปลงข้อความในตัวที่กำหนดค่าได้ซึ่งฉันได้เพิ่มลงใน Jelly ตามคำแนะนำของ @ lirtosiast

อินพุตอยู่ในหัวเรื่อง, เอาต์พุตคือพลังของ 1.1 โดยมีข้อผิดพลาดน้อยที่สุด

ลองออนไลน์!

มันทำงานอย่างไร

คำตอบนี้ประกอบด้วยเพียงสองส่วน

• ก่อนอื่น“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥใช้บิวด์อินใหม่เพื่อแมปอินพุตที่เป็นไปได้ 20 รายการกับจำนวนเต็ม 15 ตัว
• จากนั้น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]$$1$$376510639244$

$0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

ต่อไปเราจะสร้างจำนวนเต็ม 64 64 บิตโดยใช้SHAKE256-4096กับการแทนค่าสตริงของการแทนค่าภายในของḥอาร์กิวเมนต์ที่ถูกต้องจากนั้นก็ทำการสับผลลัพธ์ 4096 บิตเป็น 64 บิต 64 บิต

ḥ$2^{64}$$[0, 2^{64})$

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

เพื่อหาข้อมูลการกำหนดค่าแฮชที่เหมาะสมผมเคยใช้เดรัจฉาน forcer ใน C ที่เป็นส่วนหนึ่งของ repo

Python 2 , 155 ไบต์, คะแนน = 155

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

ลองออนไลน์!

น่าแปลกใจสำหรับโซลูชั่นขี้เกียจนี้ ... จะมีการปรับปรุงเช่นกัน ;-)

Japt , 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

ทดลองใช้ปัจจัยการผลิตทั้งหมด , การคำนวณคะแนนหรือตรวจสอบข้อผิดพลาดสูงสุด

คล้ายกับคำตอบดั้งเดิมของ Olivier อินพุตเป็นตัวพิมพ์เล็กทั้งหมด

หลังจากการปรับปรุงค่าเอาต์พุตต่าง ๆ ข้อผิดพลาดสูงสุดในปัจจุบันคือ Venus ที่มากกว่า 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

สตริงสำหรับชื่อถูกsujusaurneeavemagatimecaiomoeutrplerhaบีบอัดโดยใช้การบีบอัดในตัวของ Japt ตัวเลขที่แสดงถึงรัศมีถูกคำนวณดังนี้:

                          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

Japt, 77 76 75 ไบต์, คะแนน = 75

ผ่านครั้งแรกที่นี้; ฉันต้องการลองวิธีแก้ปัญหาการลงโทษ 0 เพื่อให้ตัวเองเป็นพื้นฐานในการทำงาน จะกลับมาอีกในวันพรุ่งนี้เพื่อดูว่าสามารถทำการปรับปรุงอะไรได้บ้างหวังว่าจะยังคงมีค่าปรับ 0

อินพุตไม่คำนึงถึงขนาดตัวพิมพ์

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

ลองใช้หรือทดสอบอินพุตทั้งหมด

"..."แทนสตริงที่มีหลาย unprintables codepoints คือ:

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 ตัว จากนั้นเราสร้างดัชนีลงในอาร์เรย์นั้นโดยใช้สูตรส่วนหนึ่งของovsบวกการตัดดัชนีบางส่วนจากนั้นจึงจับคู่อักขระ 2 ตัวกับ codepoint ของพวกเขา

• บันทึกเป็นไบต์ / จุดด้วยETH

54 ไบต์, คะแนน = 58

พอร์ตของการแก้ปัญหาของโอลิเวีย

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

ทดสอบอินพุตทั้งหมด

Ruby , 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)}

ลองออนไลน์!

หากเราหาร 700,000 ด้วยรัศมีเราจะได้ลำดับที่เพิ่มขึ้นเป็นเส้นตรงอย่างสมเหตุสมผล (แม้ว่าค่อนข้างผิดปกติ) การเพิ่มขึ้นของตารางด้านล่างสามารถประมาณได้โดยค่า ASCII ของอักขระ ปัญหาของวิธีการนี้คือต้องการให้อินพุตถูกถอดรหัสเป็นค่าซึ่งเรียงลำดับชื่อตามขนาดต่างกัน

ปัญหาเล็กน้อยคือความแตกต่างระหว่าง Eris และ Haumea นั้นค่อนข้างใหญ่ ~~dต้องมีอักขระสามตัวเพื่อเข้ารหัสส่วนเพิ่มนี้ในรูปแบบ ASCII เท่านั้น สตริงดาวเคราะห์ต่อดัชนีมีสองช่องว่าง "ดาวเคราะห์ดาวเคราะห์" เพื่อเป็นดัชนี

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

T-SQL, 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)

การขึ้นบรรทัดใหม่มีไว้เพื่อให้สามารถอ่านได้เท่านั้น

การป้อนข้อมูลจะได้รับการผ่านตารางที่มีอยู่ก่อนผมกับคอลัมน์ varchar วี , ตามมาตรฐาน IO ของเรา

รวมตารางอินพุตเข้ากับตารางในหน่วยความจำของอักขระสองตัวแรกและส่งคืนตัวเลขที่เหลืออยู่ x100

ถือว่า "ไททัน" IIFเป็นกรณีพิเศษโดยใช้

แก้ไข : บันทึก 1 ไบต์ (และ 1 จุด) โดยใช้การลบตัวละครสองตัวแรกแทนSTUFF SUBSTRINGขอบคุณ t-clausen.dk!

แก้ไข 2 : ฉันต้องการดูว่าจะเกิดอะไรขึ้นถ้าฉันพยายามบันทึกไบต์อื่นด้วยการคูณค่าการค้นหาแต่ละค่าด้วย 99 แทนที่จะเป็น 100 และพบว่าฉันประหลาดใจว่ามันเพิ่มความแม่นยำจริง ๆ

สิ่งนี้นำฉันไปสู่การลองผิดลองถูกและการทดสอบข้อผิดพลาดและตารางข้อมูลแบบ what-if จาก Excel ที่ฉันพบโซลูชันที่ดีที่สุดโดยใช้ตัวคูณ89ซึ่งแน่นอนการเปลี่ยนแปลงค่าที่เก็บไว้ทั้งหมดของฉัน

ดังนั้นในขณะนี้สิ่งนี้จะช่วยฉันเพียงหนึ่งไบต์ แต่ก็ช่วยเพิ่มคะแนน4.6จากโซลูชันก่อนหน้าของฉัน

แก้ไข 3 : ค้นหาที่สูงขึ้นแทนการลดลงและพบว่าแม้จะดีกว่าปัจจัยคูณ198 ค่ายังคงมีเหตุผลที่ถูกต้องในขณะที่ทำให้สตริงที่เก็บไว้สั้นลงด้วยตัวอักษรไม่กี่ตัวซึ่งทำให้คะแนนของฉันดีขึ้น

PowerShell , 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]

ลองออนไลน์!

คล้ายกับคำตอบของโอลิเวียร์มากตอนนี้ที่ฉันเห็น แต่พัฒนาอย่างอิสระ

ถ่าน , 101 bytes, score = 101

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

⁺§θ⁰§θχ

ใช้อักขระที่ 1 และ 11 (cyclically) ของสตริงอินพุตและต่อกัน

⌕⪪”@/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 (<ออกเป็นกลุ่มที่มีสามอักขระและเลือกกลุ่มที่เกี่ยวข้อง

Ｉ⍘ ... γ

ถอดรหัสผลลัพธ์เป็นหมายเลขเบส -95 โดยใช้ชุดอักขระ ASCII ที่พิมพ์ได้ซึ่งเป็นตัวเลข ตัวอย่าง: Io's ตัวละครที่ 11 คือIเพื่อให้เราขึ้นไปดูIIและพบว่ามันเป็นวัตถุที่ใหญ่ที่สุด 13 และขนาดของมันเป็นที่แมปไป3119 * 95 + 17 = 1822

สวิฟท์ 4 , 225 ไบต์, คะแนน = 241

น่าจะเล่นกอล์ฟได้มากขึ้น (อาจอยู่ในพื้นที่ "Ga-Me-Ca") แต่ Swift ไม่ได้ใช้บ่อย (ด้วยเหตุผลอาจจะ)

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

และ ungolfed

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 ตัวอักษร) ฉันคิด).

JavaScript (ES6), 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

ลองออนไลน์!

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

C (gcc) , 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);}

ลองออนไลน์!

เกณฑ์การให้คะแนน

rundown

ชื่อวัตถุถูกเปลี่ยนเป็นแฮชอักขระเดียวผ่านกระบวนการที่ยุ่งยาก

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

ซึ่งมีคะแนนชี้ไปที่ "ไททัน" / "ไททาเนีย" ในฐานะผู้กระทำผิดหลัก รวมถึงตัวละครตัวสุดท้ายในแฮชที่ได้รับการพิจารณา แต่ก็ยังต้องมีstrlen()ใน C การเกิดขึ้นครั้งแรกของอักขระแฮชจะถูกค้นหาในสตริงแฮช / ข้อมูล เมื่อพบตัวละครต่อไปจะถูกนำมาใช้และใช้ในการประมาณรัศมีของวัตถุที่เป็นปัญหา

อักขระข้อมูลเก็บลอการิทึมฐานเลื่อนตามธรรมชาติของรัศมี สร้างเช่น:

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

Python 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 ตามสตริงอินพุตโดยใช้การแก้ไขของ @Erik the Python 2 ของ Outgolfer ฉันบันทึกสองสามไบต์ลงบนโค้ดของเขาโดยการทำให้สมการของฉันกลับมาใช้งานกับ [2..40] แทน [1..20]

รหัสสำหรับการสร้างคำสั่งการจัดอันดับใช้เวลามากกว่า 2/3 ของไบต์ของโซลูชันทั้งหมด หากใครมีวิธีสร้างอันดับที่กระชับกว่านี้โซลูชันนี้อาจสั้นลงอีก เนื่องจากการลงโทษความแม่นยำ (ประมาณ 2.6) คะแนนจะดีขึ้นเล็กน้อย

การสร้างสมการ

ฉันใช้วิธีการทางสถิติเพื่อค้นหาสมการอย่างง่ายเพื่อประมาณขนาดของร่างกายแต่ละอันตามอันดับของมัน ในส่วนของการติดตามข้อมูลเชิงลึกในโซลูชัน Ruby ของ @Level River St และการวางหลักเกณฑ์ทั่วไปฉันตัดสินจากสมการของรูปแบบ:

Radius = A/(Rank)**B

ทำงานใน R ฉันใช้แบบจำลองเชิงเส้นในบันทึกของรัศมีเพื่อพัฒนาการประมาณค่าเริ่มต้นจากนั้นใช้การปรับให้เหมาะสมแบบไม่เชิงเส้นการเพิ่มประสิทธิภาพด้วยผลลัพธ์ของแบบจำลองเชิงเส้นเพื่อค้นหาโซลูชันที่ลดฟังก์ชันการลงโทษที่ระบุไว้ใน ปัญหา.

ค่าโดยประมาณของ A ในสมการข้างต้นคือเจ็ดหลักดังนั้นฉันค้นหานิพจน์อย่างง่ายเพื่อบันทึกสองไบต์ ฉันมองหาการแสดงออกของแบบฟอร์ม

x**y

สำหรับสองหลัก x และ 1 หลัก y (รวมเป็นห้าไบต์บันทึกสองไบต์หรือประมาณห้าจุดได้รับการลงโทษ) ซึ่งไม่แตกต่างจากค่าที่เหมาะสมที่สุดของ A และไม่ขยายการลงโทษมากเกินไปและสิ้นสุดลง ขึ้นกับ (อธิบายไม่ได้):

39**4

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

โปรแกรม "index in string to list" แบบง่าย สามารถตีกอล์ฟต่อไปได้

อินพุตอยู่Ansและเป็นหนึ่งในชื่อของวัตถุที่เป็นตัวพิมพ์ใหญ่แบบเต็ม
เอาต์พุตอยู่ในAnsและพิมพ์ออกมาโดยอัตโนมัติ

ตัวอย่าง:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

คำอธิบาย:
(รายการ Radii และสตริงชื่อสั้นลงเพราะความกะทัดรัด...ใช้เพื่อระบุส่วนที่เหลือของรายการ / สตริง)

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