太陽系の20の最大のオブジェクトの1つの名前が与えられます。あなたの仕事は、キロメートル単位で表した半径の近似値を返すことです。

これはコードチャレンジであり、スコアはコードの長さ（バイト単位）にペナルティ率掛けたもので、最悪の近似に基づいています。したがって、最低スコアが勝ちます。$\ge 1$

_{「私たちが宇宙を旅するように」は、ブラックサバスの「Planet Caravan」という歌の最後の行であり、後にPanteraにも取り上げられました。}

太陽系オブジェクト

ソース：ウィキペディア

注意：ランクは情報提供のみを目的としています。入力はオブジェクトの名前です。

  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$

例：

コードのサイズがバイトで、最悪の近似値が km ではなく kmの推定半径の月にある場合、スコアは次のようになります。$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文字の両方を使用します（ただし、Javaはそれを受け入れます）。TIOで正確なコードを確認してください。
• 入力はタイトルケースでなければなりません。
• このコードは、エンコード時に最後の2桁をスキップできるように、値を最適な100の倍数（場合によっては切り上げ、切り捨て）に丸め、100を掛けて値を概算できます。
• このエントリはさまざまなハッシュを使用して、25コードポイント文字列（私が見つけることができる最短の文字列）に適合します。

クレジット

• -48スコア（-45バイト）は、半径（100で割った値）を明示的な配列にハードコーディングする代わりに直接エンコードすることにより、Kevin Cruijssenに感謝します。Stringint

Wolfram言語114 103 97 88 86 82バイト スコア= 114103 97 89 87 83ポイント

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

少なくとも6点のおかげで保存されDennis、よりいくつかのおかげで、lirtosiast、および6つのより感謝をuser202729。

Mathematicaは太陽系データ（および多くの追加の天文データ）を取得できますが、以下で説明するように、若干の微調整が必​​要です。

Interpreter[#,"AstronomicalObject"]&は、で表される用語に関連付けられたエンティティ（マシン計算可能オブジェクト）を返します#。

EntityValue[AstronomicalObject[],"Radius"]エンティティの半径をマイル単位で返します。「Haumea」の場合、値816.27（つまり507 * 1.61）が返されます。

半径を乗算1.61してマイルをkmに変換します。最も極端な場合でも、整数ではなく10進値が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バイト、スコア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

説明：

• 名前には文字のみが含まれ、半径に​​は数字とドットが含まれます。したがって、データ文字列にすべてのデータを書き込み、正規表現検索を実行できます。
• スクリプトは、左から右にすべての部分文字列を検索し、最後に見つかった結果を取得します。
• データ文字列を減らすために、入力はタイトルケースでなければなりません。
• 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%èт*

@OlivierGrégoireのJava回答のポートです。この最初の回答が気に入った場合は、必ず彼も賛成してください！
タイトルケースに入力します。

すべてのテストケースを確認します。

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; [uranus、neptune]から30,000; [地球、金星]から6,000; [火星、ガニメデ、チタン、水銀、カリスト]に3,000、[io、moon、europa、triton、pluto、eris] to 1,500; および[haumea; titania]に750。残念ながら、それは117のスコアを獲得しました。後で別のアプローチで100を下回ることができるかどうかを確認します。

Mathematica、57バイト、スコア = 62 58

^{lirtosiastのおかげで-4バイト/スコア！}

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

平均半径のWolfram Alphaルックアップを行うだけです。

ゼリー、28バイト、スコア= 31

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

これは、@ lirtosiastの提案でJellyに追加した構成可能なハッシュ組み込みを使用します。

入力はタイトルケースで、出力は最小のエラーで1.1の累乗です。

オンラインでお試しください！

使い方

この答えは、2つの部分だけで構成されています。

• 最初に“__ʋ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]$

次に、SHAKE256-4096をḥの正しい引数の内部表現の文字列表現に適用し、結果の4096ビットを64個の64ビットチャンクに切り刻むことにより、64個の64ビット整数を生成します。

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

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

適切なハッシュ構成を見つけるために、私はJellyリポジトリの一部である Cでブルートフォーサーを使用しました。

Python 2、155バイト、スコア = 155

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

オンラインでお試しください！

この怠solutionな解決策には驚くべきことに...改善も検討します。;-)

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

すべての入力で試してみる、スコアを計算する、または最高のエラーを確認する

オリビエの元の答えに非常に似ています。入力はすべて小文字です。

出力値にさまざまな改善を加えた後、現在の最大エラーは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

Japt、77 76 75バイト、スコア= 75

これで最初のパス。ペナルティ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文字のチャンクに分割されます。次に、ovsの式の一部とインデックスラッピングを使用してその配列にインデックスを付け、2文字をコードポイントにマッピングします。

• ETHのおかげで1バイト/ポイント節約

54バイト、スコア= 58

Olivierのソリューションの移植版。

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

すべての入力をテストする

ルビー、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)}

オンラインでお試しください！

700000を半径で除算すると、合理的に線形に増加するシーケンスが得られます（かなり不規則に）。次の表の増分は、文字のASCII値で概算できます。このアプローチの問題は、サイズによって異なる名前を並べ替える値に入力をデコードする必要があることです。

小さな問題は、エリスとハウメアの違いが非常に大きいことです。~~dこの増分をASCIIのみの形式でエンコードするには、3文字が必要です。惑星からインデックスへの文字列には、インデックスを埋めるために2つの「ゴーストプラネット」スペースがあります。

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 212208

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列でV、私たちのIO規格ごと。

入力テーブルを最初の2文字でメモリ内テーブルに結合し、残りの数字x100を返します。

を使用して、「Titan」を特別なケースとして扱いIIFます。

編集：のSTUFF代わりに最初の2文字を消去するために使用して、1バイト（および1ポイント）を保存しましたSUBSTRING。ありがとう、t-clausen.dk！

編集2：各ルックアップ値を100ではなく99で乗算して別のバイトを保存しようとするとどうなるかを知りたいと思ったのですが、実際に（最低精度の推定値の）精度が向上したことに驚きました！

これにより、試行錯誤のテストと、空想的なExcelのwhat-ifデータテーブルが作成され、89の乗数を使用して最適なソリューションが見つかりました（もちろん、保存されているすべての値が変更されました）。

したがって、これで1バイトしか節約できませんが、実際には、以前のソリューションからスコアが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バイト、スコア= 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 (<を3文字のグループに分割し、対応するグループを取得します。

Ｉ⍘ ... γ

印刷可能なASCII文字セットを数字として使用して、結果をbase-95数としてデコードします。例：Ioの11番目の文字はIですのでII、検索して13番目に大きいオブジェクトであることがわかり、そのサイズは31にマップされ19 * 95 + 17 = 1822ます。

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

そして、未調理

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には多くの衝突があり、3文字を使用してもi=="Titan" ?2575:17文字にはなりません。おもう）。

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!]?

単語の長さと最初の文字を使用した怠answerな答えですが、私の言い訳は変な言語を使用しているということです

オンラインでお試しください！（コードをコピーして貼り付け、ショーを押してから実行します）

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

オンラインでお試しください！

得点

流れ落ちる

面倒なプロセスにより、オブジェクト名は単一文字のハッシュに変換されます

(((*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はボディの半径のランク順の2倍です。

@Erik the OutgolferのPython 2ソリューションの修正を使用して、入力文字列に基づいてxの値を生成します。[1..20]の代わりに[2..40]で動作するように方程式を作り直して、彼のコードに数バイトを保存しました。

ランク順を生成するコードは、ソリューション全体の2/3を超えるバイトを占めます。誰かがランクを生成するよりコンパクトな方法を持っている場合、このソリューションはさらに短縮される可能性があります。精度のペナルティ（約2.6）のため、スコアはかなり改善されます。

方程式の生成

統計手法を使用して単純な方程式を検索し、ランクに基づいて各ボディのサイズを推定しました。@Level River StのRubyソリューションの洞察をフォローアップし、一般化することで、次の形式の方程式を決定しました。

Radius = A/(Rank)**B

Rで作業し、半径の対数で線形モデルを使用して初期推定値を作成し、次に非線形最適化を使用して、線形モデルの結果で最適化をシードし、で指定されたペナルティ関数を最小化するソリューションを検索しました問題。

上記の式のAの推定値は7桁なので、数バイトを節約するために簡単な式を検索しました。フォームの表現を探しました

x**y

2桁のxと1桁のy（ペナルティを考慮して合計5バイト、2バイトを節約、または約5ポイント）に対して、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

単純な「リストする文字列のインデックス」プログラム。さらにゴルフすることができます。

入力はinでAnsあり、オブジェクトの完全な大文字の名前の1つです。
出力は入力され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