PowerShell, 3 bytes, score 3637

2e4

Try it online!

Very naive, boring, implementation; just returns 20000 no matter the input. Experimentation with things like special-casing the sun or using floating-point values instead of 2 all resulted in worse scores because the length of code increased enough to offset any size-comparison gains.

Jelly, 34 bytes, score = 37

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

Input is in uppercase, output is the power of 1.1 with the least error.

Try it online!

How it works

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 bytes, score = 97

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

Try it online!

• This entry uses both undisplayable and multi-byte Unicode characters (but Java accepts them nevertheless). Check the TIO for the accurate code.


• The input must be title-case.


• This code rounds the values to the best multiple-of-100 (sometimes up, sometimes down) so that the last two digits can be skipped when encoded, and the value can then be approximated by multiplying by 100.


• This entry uses various hashes to fit a 25 codepoints string (shortest string I could find).

Credits

• -48 score (-45 bytes) thanks to Kevin Cruijssen by encoding the radiuses (divided by 100) directly in a String instead of hardcoding them in an explicit int array..

Wolfram Language 114 103 97 88 86 83 bytes. score = 114 103 97 89 87 84 points

#&@@EntityValue[Interpreter["AstronomicalObject"]@#,"Radius"]/."NotAvailable"->816&

At least 6 points saved thanks to Dennis, several more thanks to lirtosiast, and 2 more thanks to user202729.

Although Mathematica can fetch solar system data (as well as much additional astronomical data), some minor tweaks are needed, as explained below.

Interpreter[#,"AstronomicalObject"]& will return the entity (i.e. the machine computable object) associated with the term represented by #.

EntityValue[AstronomicalObject,"Radius"] returns the radius, in miles, of the entity.

"Haumea" returns the value, "NotAvailable", which is replaced by 816.

Multiplication of the radius by 1.61 converts from miles to km. Decimal values, rather than integers, account for much less than 1% error, even in the most extreme case.

[[1]] returns the magnitude without the unit, km. This was later changed to #&@@, yielding the same result.

Python 3, score 95, 95 bytes

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

Try it online!

Python 3, score 133, 133 bytes

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)

Try it online!

05AB1E, score 100 66 60 (100 61 56 bytes)

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

Port of @OlivierGrégoire's Java answer, so if you like this first answer, make sure to upvote him as well!

Input in titlecase.

Verify all test cases.

05AB1E, score 100 (100 bytes)

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

Input in full lowercase. Outputs the exact radius, so no penalty is added.

Verify all test cases.

Explanation:

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

See this 05AB1E tip of mine (sections How to compress large integers? and How to compress strings not part of the dictionary?) to understand how the compression used works.

I did create a 70-bytes alternative which would map sun to 600,000; [jupiter,saturn] to 60,000; [uranus,neptune] to 30,000; [earth,venus] to 6,000; [mars,ganymede,titan,mercury,callisto] to 3,000; [io,moon,europa,triton,pluto,eris] to 1,500; and [haumea;titania] to 750. Unfortunately that got a score of 117. I will see if I can get below 100 with an alternative approach later.

Mathematica, 57 bytes, score = 62 58

^{-4 bytes/score thanks to lirtosiast!}

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

Just does a Wolfram Alpha lookup for the mean radius.

Powershell, 150 bytes, score 163

($args|% t*y|?{'Su680J68S57U25N24Ea6V6Ma3.3G2.6Ti2.5Me2.4C2.4I1.8M1.7Eu1.5T1.3P1.2E1.1H.8Titani.8'-cmatch"$(($y+=$_))([d.]+)"}|%{1kb*$Matches.1})[-1]

Test script:

$f = {

($args|% t*y|?{'Su680J68S57U25N24Ea6V6Ma3.3G2.6Ti2.5Me2.4C2.4I1.8M1.7Eu1.5T1.3P1.2E1.1H.8Titani.8'-cmatch"$(($y+=$_))([d.]+)"}|%{1kb*$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"

Output:

162.113324228916 = 150 * 1.08075549485944

Explanation:

• Names contain letters only, radiuses contain digits and dots. So we can write all the data in a data string and perform a regexp search.


• The script searches for all substrings from left to right and takes the last result found.


• The input must be title-case to reduce the data string.


• The end of line mode is LF only.

Example:

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 bytes, score 178

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

Japt, 86 bytes, score = 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

Try it for all inputs, Calculate the score, or Check the highest error

Very similar to Olivier's original answer. Input is all lowercase.

After various improvements to the output values, the current highest error is Venus at just over 4%.

Explanation now that things are a bit more stable:

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

The string for the names is sujusaurneeavemagatimecaiomoeutrplerha compressed using Japt's built-in compression. The numbers representing the radii are calculated like so:

                          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 bytes, score = 75

First pass at this; I wanted to try a 0 penalty solution to give myself a baseline to work off. Will come back to it tomorrow to see what improvements can be made, hopefully still for 0 penalty.

Input is case-insensitive.

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

Try it or test all inputs

The "..." represents a string containing many unprintables. The codepoints are:

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

To offer a quick explanation: the string gets split into chunks of 2 characters. We then index into that array using part of ovs' formula plus some index-wrapping and then map the 2 characters to their codepoints.

• Saved a byte/point thanks to ETH
  

54 bytes, score = 58

A port of Olivier's solution.

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

Test all inputs

PowerShell, 203 bytes, score 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]

Try it online!

Very similar to Olivier's answer, now that I see it, but developed independently.

Python 2, 155 bytes, score = 155

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

Try it online!

Surprisingly well for this lazy solution... will look into improving as well. ;-)

T-SQL, 203 bytes, score = 217

SELECT IIF(v='Titan',26,SUBSTRING(value,3,4))*100

FROM i,STRING_SPLIT('Ca24,Ea64,Er12,Eu16,Ga26,Ha8,Io18,Ju699,Ma34,Me24,Mo17,Ne246,Pl12,Sa582,Su6963,Ti8,Tr14,Ur254,Ve61',',')

WHERE LEFT(v,2)=LEFT(value,2)

Line breaks are for readability only.

Input is taken via pre-existing table i with varchar column v, per our IO standards.

Joins the input table to an in-memory table on the first two characters, and returns the remaining digits x100.

Treats "Titan" as a special case using IIF.

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

Try it online!

If we divide 700000 by the radii, we get a sequence which increases reasonably linearly (though rather erratically). The increments in the table below can be approximated by the ASCII values of characters. The problem with this approach is it requires the input to be decoded to a value which orders the different names by size.

A minor issue is that the difference between Eris and Haumea is quite large. Three characters ~~d are required to encode this increment in ASCII only format. The planet-to-index string has two "ghost planet"spaces in it to pad the index.

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

Charcoal, 101 bytes, score = 101

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

Try it online! Link is to verbose version of code. Explanation:

⁺§θ⁰§θχ

Take the 1st and 11th character (cyclically) of the input string and concatenate them.

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

Look them up in the string SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTa split into pairs of characters.

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

Split the string m.w'fv&J|"l|"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (< into groups of three characters and take the corresponding group.

Ｉ⍘ ... γ

Decode the result as a base-95 number using the printable ASCII character set as the digits. Example: Io's 11th character is I, so we look up II and find it's the 13th largest object and its size is 31 which maps to 19 * 95 + 17 = 1822.