Anda akan diberi nama salah satu dari 20 objek terbesar di Tata Surya. Tugas Anda adalah mengembalikan perkiraan radiusnya, yang dinyatakan dalam kilometer.

Ini adalah tantangan kode di mana skor Anda terdiri dari panjang kode Anda (dalam byte) dikalikan dengan rasio penalti $\ge 1$ , berdasarkan perkiraan terburuk Anda. Oleh karena itu, skor terendah akan menang .

_{"As we travel the universe" adalah baris terakhir dari lagu Planet Caravan oleh Black Sabbath , yang juga belakangan diliput oleh Pantera .}

Objek Tata Surya

Sumber: Wikipedia

NB: Pangkat diberikan hanya untuk informasi. Input adalah nama objek.

  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

Atau sebagai daftar ramah tempel-tempel:

'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

Nilai Anda

Biarkan $R_n$ menjadi radius yang diharapkan dari objek $n^{th}$ dan biarkan $A_n$ menjadi jawaban program Anda untuk objek ini.

Kemudian skor Anda didefinisikan sebagai:

di mana $L$ adalah panjang kode Anda dalam bytes.

Contoh:

Jika ukuran kode Anda adalah $100$ byte dan perkiraan terburuk Anda adalah di Bulan dengan radius diperkirakan $1000$ km, bukan $1737$ km, maka skor Anda adalah:

Semakin rendah, semakin baik.

Tajuk yang disarankan untuk jawaban Anda:

Language, 100 bytes, score = 302

Anda dapat menggunakan skrip ini untuk menghitung skor Anda (baris pertama = panjang kode, 20 baris berikutnya = output Anda, dari Sun ke Titania).

Aturan

• Anda dapat mengambil nama objek dalam huruf kecil penuh, huruf besar penuh atau persis seperti yang dijelaskan di atas (case title). Kasing campuran lainnya tidak diperbolehkan.
• Input dijamin menjadi salah satu dari 20 nama yang mungkin.
• Anda dapat mengembalikan bilangan bulat atau mengapung. Dalam kedua kasus, penalti harus dihitung secara langsung dengan nilai-nilai ini (bukan nilai bulat jika float).
• Anda harus mengembalikan nilai positif.
• Program kosong tidak diizinkan.

PowerShell , 3 byte, skor 3637

2e4

Cobalah online!

Sangat naif, membosankan, implementasi; hanya mengembalikan 20000input apa pun. Eksperimen dengan hal-hal seperti casing-khusus matahari atau menggunakan nilai-nilai floating-point bukannya 2semua menghasilkan skor yang lebih buruk karena panjang kode meningkat cukup untuk mengimbangi setiap keuntungan perbandingan ukuran.

Jelly , 34 byte, skor = 37

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

Input dalam huruf besar, output adalah kekuatan 1,1 dengan kesalahan paling sedikit.

Cobalah online!

Bagaimana itu bekerja

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 byte, skor = 97

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

Cobalah online!

• Entri ini menggunakan karakter Unicode yang tidak dapat diputar dan multi-byte (tetapi Java tetap menerimanya). Periksa TIO untuk kode yang akurat.
• Masukan harus berupa judul-kasus.
• Kode ini membulatkan nilai ke kelipatan 100 terbaik (kadang-kadang naik, kadang turun) sehingga dua digit terakhir dapat dilewati saat disandikan, dan nilainya kemudian dapat diperkirakan dengan mengalikan dengan 100.
• Entri ini menggunakan berbagai hash agar sesuai dengan string 25 codepoint (string terpendek yang bisa saya temukan).

Kredit

• Skor -48 (-45 bytes) terima kasih kepada Kevin Cruijssen dengan menyandikan radio (dibagi 100) langsung di Stringhardcoding bukan dalam intarray eksplisit ..

Bahasa Wolfram 114 103 97 88 86 82 byte. skor = 114 103 97 89 87 83 poin

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

Setidaknya 6 poin disimpan berkat Dennis, beberapa lagi berkat lirtosiast, dan 6 lagi berkat user202729.

Meskipun Mathematica dapat mengambil data tata surya (serta banyak data astronomi tambahan), beberapa perubahan kecil diperlukan, seperti yang dijelaskan di bawah ini.

Interpreter[#,"AstronomicalObject"]&akan mengembalikan entitas (yaitu objek yang dapat dihitung mesin) yang terkait dengan istilah yang diwakili oleh #.

EntityValue[AstronomicalObject[],"Radius"]mengembalikan jari-jari, dalam mil, dari entitas. Dalam kasus "Haumea", nilai, 816.27 (yaitu 507 * 1.61), dikembalikan.

Perkalian jari-jari dengan 1.61mengkonversi dari mil ke km. Nilai desimal, bukan bilangan bulat, bertanggung jawab atas kesalahan kurang dari 1%, bahkan dalam kasus paling ekstrem.

[[1]]mengembalikan besarnya tanpa unit, km. Ini kemudian diubah menjadi #&@@, menghasilkan hasil yang sama.

Python 3 , skor 95, 95 byte

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

Cobalah online!

Python 3 , skor 133, 133 byte

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)

Cobalah online!

Powershell, 150 141 byte, skor 163 153

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

Cobalah online!

Skrip uji:

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

Keluaran:

152.731283431953 = 141 * 1.08320059171598

Penjelasan:

• Nama hanya berisi huruf, jari-jari mengandung digit dan titik. Jadi kita bisa menulis semua data dalam string data dan melakukan pencarian regexp.
• Script mencari semua substring dari kiri ke kanan dan mengambil hasil terakhir yang ditemukan.
• Input harus berupa judul-huruf untuk mengurangi string data.
• Hanya end of line modeLF.

Contoh:

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 byte, skor 178

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

05AB1E , skor 100 66 60 ( 100 61 56 byte )

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

Port of @ OlivierGrégoire 's Java answer , jadi jika Anda menyukai jawaban pertama ini, pastikan untuk menambahkannya juga!
Masukan dalam titlecase.

Verifikasi semua kasus uji.

05AB1E , skor 100 (100 byte )

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

Masukan dalam huruf kecil penuh. Menghasilkan jari-jari yang tepat, sehingga tidak ada penalti yang ditambahkan.

Verifikasi semua kasus uji.

Penjelasan:

•*Òâ%ÌÜ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)

Lihat tip tambang 05AB1E ini (bagian Bagaimana cara mengkompres bilangan bulat besar? Dan Bagaimana mengompresi string bukan bagian dari kamus? ) Untuk memahami bagaimana kompresi digunakan bekerja.

Saya memang membuat alternatif 70-byte yang akan memetakan matahari ke 600,000; [jupiter, saturn] ke 60,000; [uranus, neptune] ke 30,000; [bumi, venus] ke 6,000; [mars, ganymede, titan, mercury, callisto] untuk 3,000; [io, bulan, europa, triton, pluto, eris] ke 1,500; dan [haumea; titania] ke 750. Sayangnya itu mendapat skor 117. Saya akan melihat apakah saya bisa mendapatkan di bawah 100 dengan pendekatan alternatif nanti.

Mathematica, 57 byte, skor = 62 58

^{-4 Bytes / skor berkat lirtosiast !}

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

Lakukan saja pencarian Wolfram Alpha untuk radius rata-rata.

Jelly , 28 byte, skor = 31

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

Ini menggunakan hashing yang dapat dikonfigurasi bawaan yang saya tambahkan ke Jelly pada saran @ lirtosiast.

Input dalam titlecase, output adalah kekuatan 1,1 dengan kesalahan paling sedikit.

Cobalah online!

Bagaimana itu bekerja

Jawaban ini hanya terdiri dari dua bagian.

• Pertama, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥgunakan built-in baru untuk memetakan masing-masing dari 20 input yang mungkin ke 15 bilangan bulat yang berbeda.
• Kemudian, 1.1*naikkan 1,1 ke daya yang dihitung.

“__ʋ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]$

Selanjutnya, kita menghasilkan 64 bilangan bulat 64-bit dengan menerapkan SHAKE256-4096 ke representasi string dari representasi internal ḥargumen kanan, kemudian memotong 4096 bit yang dihasilkan menjadi 64 64-bit potongan.

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

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

Untuk menemukan konfigurasi hash yang sesuai, saya telah menggunakan brute-forcer dalam C yang merupakan bagian dari repo Jelly .

Python 2 , 155 byte, skor = 155

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

Cobalah online!

Anehnya baik untuk solusi malas ini ... akan terlihat membaik juga. ;-)

Japt , 86 byte, skor = 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

Cobalah untuk semua input , Hitung skor , atau Periksa kesalahan tertinggi

Sangat mirip dengan jawaban asli Olivier. Input semua huruf kecil.

Setelah berbagai peningkatan nilai output, kesalahan tertinggi saat ini adalah Venus di atas 4%.

Penjelasan sekarang bahwa segalanya sedikit lebih stabil:

¤¥`É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

String untuk nama-nama sujusaurneeavemagatimecaiomoeutrplerhadikompres menggunakan kompresi bawaan Japt. Angka-angka yang mewakili jari-jari dihitung seperti ini:

                          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 byte, skor = 75

Pass pertama di ini; Saya ingin mencoba solusi penalti 0 untuk memberikan saya dasar untuk bekerja. Akan kembali ke sini besok untuk melihat perbaikan apa yang bisa dilakukan, semoga masih untuk 0 penalti.

Input tidak peka huruf besar-kecil.

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

Cobalah atau uji semua input

The "..."mewakili string yang berisi banyak unprintables. Codepoint adalah:

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

Untuk menawarkan penjelasan cepat: string dipecah menjadi potongan 2 karakter. Kami kemudian mengindeks ke dalam array itu menggunakan bagian dari formula ovs ditambah beberapa pembungkus indeks dan kemudian memetakan 2 karakter ke codepoint mereka.

• Menyimpan byte / titik berkat ETH

54 byte, skor = 58

Port solusi Olivier .

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

Uji semua input

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

Cobalah online!

Jika kita membagi 700.000 dengan jari-jari, kita mendapatkan urutan yang meningkat secara linear (meskipun agak tidak menentu). Peningkatan dalam tabel di bawah ini dapat diperkirakan dengan nilai karakter ASCII. Masalah dengan pendekatan ini adalah membutuhkan input untuk diterjemahkan ke nilai yang memesan nama yang berbeda berdasarkan ukuran.

Masalah kecil adalah bahwa perbedaan antara Eris dan Haumea cukup besar. ~~dDiperlukan tiga karakter untuk menyandikan kenaikan ini dalam format ASCII saja. String planet-to-index memiliki dua ruang "planet hantu" di dalamnya untuk mengisi indeks.

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 byte, skor = 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)

Jeda baris hanya untuk keterbacaan.

Input diambil melalui tabel i yang sudah ada sebelumnya dengan kolom varchar v , sesuai standar IO kami .

Bergabung dengan tabel input ke tabel di-memori pada dua karakter pertama, dan mengembalikan x100 digit yang tersisa.

Memperlakukan "Titan" sebagai kasus khusus menggunakan IIF.

EDIT : Disimpan 1 byte (dan 1 poin) dengan menggunakan STUFFuntuk menghapus dua karakter pertama, bukan SUBSTRING. Terima kasih, t-clausen.dk!

EDIT 2 : Saya ingin melihat apa yang akan terjadi jika saya mencoba menyimpan byte lain dengan mengalikan masing-masing nilai pencarian dengan 99 bukannya 100, dan ternyata mengejutkan bahwa itu benar-benar meningkatkan akurasi (dari perkiraan paling tidak akurat) !.

Ini membawa saya ke beberapa uji coba dan kesalahan, dan beberapa tabel data Excel what-if yang mewah, di mana saya menemukan solusi optimal menggunakan pengganda 89 (yang tentu saja mengubah semua nilai yang disimpan).

Jadi, sementara ini menyelamatkan saya hanya satu byte, itu sebenarnya meningkatkan skor saya sebesar 4,6 dari solusi saya sebelumnya.

EDIT 3 : Mencari lebih tinggi daripada lebih rendah, dan menemukan faktor perkalian yang lebih baik , 198 . Nilai tetap cukup akurat sambil memperpendek string yang disimpan oleh beberapa karakter, yang meningkatkan skor saya.

PowerShell , 203 byte, skor 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]

Cobalah online!

Sangat mirip dengan jawaban Olivier, sekarang saya melihatnya, tetapi berkembang secara mandiri.

Arang , 101 byte, skor = 101

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

⁺§θ⁰§θχ

Ambil karakter 1 dan 11 (secara siklis) dari string input dan gabungkan mereka.

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

Cari mereka di string yang SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTadipisah menjadi pasangan karakter.

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

Pisahkan string m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<menjadi grup tiga karakter dan ambil grup yang sesuai.

Ｉ⍘ ... γ

Dekode hasilnya sebagai angka dasar-95 menggunakan karakter ASCII yang dapat dicetak ditetapkan sebagai digit. Contoh: IoKarakter ke 11 adalah I, jadi kita mencari IIdan menemukan bahwa itu adalah objek terbesar ke-13 dan ukurannya adalah 31yang dipetakan 19 * 95 + 17 = 1822.

Cepat 4 , 225 byte, skor = 241

Mungkin golf lebih banyak (mungkin di daerah "Ga-Me-Ca"?), Tetapi Swift tidak sering digunakan (karena suatu alasan, mungkin.)

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

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

Cobalah secara Online!

Saya mencoba "ukuran kunci" yang berbeda untuk peta, tetapi tentu saja 1 memiliki banyak bentrokan dan menggunakan tiga karakter tidak memberi saya i=="Titan" ?2575:17 karakter, karena ada "Io" untuk dikelola (dan akan membutuhkan lebih dari 3 karakter, Kupikir).

JavaScript (ES6), 152 byte, skor = 163

Ya, ini solusi standar yang cantik, tapi saya tetap menikmati tantangannya!

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

Skor saya:

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

Cobalah secara Online!

SALAH , 152 byte, Skor = 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!]?

Jawaban malas menggunakan panjang kata dan huruf pertama tetapi alasan saya adalah bahwa saya menggunakan bahasa yang aneh

Cobalah online! (salin tempel kode, tekan show lalu jalankan)

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

Hasil saya:

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 byte, skor = 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);}

Cobalah online!

Mencetak gol

Kehabisan

Nama objek diubah menjadi hash karakter tunggal melalui proses rumit

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

yang mengasapi menunjuk ke "Titan" / "Titania" sebagai pelaku utama. Termasuk karakter terakhir dalam hash dianggap, tetapi itu masih membutuhkan strlen()dalam C. Kejadian pertama karakter hash dicari dalam string hash / data. Saat ditemukan, karakter berikutnya diambil dan digunakan untuk memperkirakan radius objek yang dimaksud.

Karakter data memegang logaritma natural bergeser dan berskala dari jari-jari. Dihasilkan seperti:

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

Skala dipilih melalui uji coba-dan-kesalahan yang sangat ilmiah, dan pergeseran untuk membawa nilai dalam kisaran ASCII yang dapat dicetak sambil menghindari backslash. Beberapa penataan ulang objek dalam string diperlukan karena beberapa tabrakan / hash data.

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 byte, Skor = 234

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

Cobalah online!

Sebagian besar jawaban yang diposting tampaknya telah menggunakan strategi "encode / decode". Saya bertanya-tanya seberapa baik yang bisa saya lakukan dengan memperkirakan diameter benda langit menggunakan persamaan sederhana. Ini merupakan latihan yang menyenangkan, tetapi penghematan byte moderat lebih dari dibuat untuk hukuman akurasi.

Inti dari solusi ini adalah persamaan estimasi:

Radius = 39**4/x**2.18

di mana x adalah dua kali urutan urutan jari-jari tubuh.

Saya menghasilkan nilai x berdasarkan input string menggunakan modifikasi dari @Erik the Outgolfer's Python 2 solusi. Saya menyimpan beberapa byte pada kodenya dengan menyusun kembali persamaan saya untuk bekerja dengan [2..40] alih-alih [1..20].

Kode untuk menghasilkan pesanan peringkat membutuhkan lebih dari 2/3 dari seluruh solusi. Jika ada yang memiliki cara yang lebih kompak untuk menghasilkan peringkat, solusi ini dapat dipersingkat lebih lanjut. Karena penalti akurasi (sekitar 2,6), skor akan meningkat sedikit.

Menghasilkan Persamaan

Saya menggunakan metode statistik untuk mencari persamaan sederhana untuk memperkirakan ukuran setiap tubuh berdasarkan peringkatnya. Sebagian menindaklanjuti wawasan dalam solusi Ruby @Level River St dan menggeneralisasi, saya menentukan persamaan bentuk:

Radius = A/(Rank)**B

Bekerja di R, saya menggunakan model linier pada log jari-jari untuk mengembangkan estimasi awal, dan kemudian menggunakan optimasi non-linear, menyemai optimasi dengan hasil model linear, untuk mencari solusi yang meminimalkan fungsi penalti yang ditentukan dalam masalah.

Nilai estimasi A dalam persamaan di atas adalah tujuh digit, jadi saya mencari ekspresi sederhana untuk menghemat beberapa byte. Saya mencari ekspresi bentuk

x**y

untuk dua digit x dan 1 digit y (untuk total lima byte, menghemat dua byte, atau sekitar lima poin, diberi penalti) yang tidak terlalu berbeda dari nilai optimal A dan tidak menggembungkan penalti banyak, dan berakhir dengan (dinyatakan tidak dapat dijelaskan):

39**4

TI-BASIC (TI-84), 285 byte, Skor = 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

Program "index in string to list" yang sederhana. Dapat bermain golf lebih lanjut.

Input dalam Ansdan merupakan salah satu nama objek dalam huruf besar penuh.
Keluaran dalam Ansdan secara otomatis dicetak.

Contoh:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Penjelasan:
(Radii list dan string nama telah disingkat untuk singkatnya. ...Digunakan untuk menunjukkan sisa dari daftar / string.)

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

Model Visual:

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