Вам дадуть ім'я одного з 20 найбільших об’єктів Сонячної системи. Ваше завдання - повернути апроксимацію його радіусу, виражену в кілометрах.

Це виклик коду, коли ваш рахунок складається з довжини коду (у байтах), помноженої на коефіцієнт штрафу , виходячи з вашого найгіршого наближення. Тому виграє найнижчий бал .$\ge 1$

_{"Поки ми подорожуємо Всесвітом" - це останній рядок пісні " Планета Караван" Black Sabbath , також пізніше висвітленої 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$

Приклад:

Якщо розмір вашого коду становить байт, а ваше найгірше наближення - на Місяці з орієнтовним радіусом км замість км, то ваш рахунок буде таким:$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 на точність коду.
• Вхід повинен бути великим регістром.
• Цей код округляє значення до кращого кратного з 100 (іноді вгору, іноді вниз), щоб останні два цифри можна було пропустити при кодуванні, а потім значення можна наблизити шляхом множення на 100.
• Цей запис використовує різні хеші для встановлення 25 рядків кодових точок (найкоротший рядок, який я міг знайти).

Кредити

• -48 балів (-45 байт) завдяки Кевіну Крейсейну , кодуючи радіуси (розділені на 100) безпосередньо Stringзамість жорсткого кодування їх у явному intмасиві ..

Мова Вольфрам 114 103 97 88 86 82 байт. оцінка = 114 103 97 89 87 83 бали

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

Принаймні 6 балів збережено завдяки Dennis, ще декілька подяк lirtosiastта ще 6 подяк user202729.

Хоча Mathematica може отримувати дані сонячної системи (а також багато додаткових астрономічних даних), потрібні деякі незначні зміни, як пояснено нижче.

Interpreter[#,"AstronomicalObject"]&поверне сутність (тобто машинно обчислюваний об'єкт), пов'язану з терміном, представленим #.

EntityValue[AstronomicalObject[],"Radius"]повертає радіус сутності в мілі. У випадку "Haumea" повертається значення 816,27 (тобто 507 * 1,61).

Множення радіуса на 1.61перетворення від миль до км. Десяткові значення, а не цілі числа, становлять набагато менше 1% помилок, навіть у самому крайньому випадку.

[[1]]повертає величину без одиниці, км. Пізніше це було змінено на #&@@такий же результат.

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 modeLF.

Приклад:

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 @ 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-байтну програму, на якій буде відображатися сонце 600,000; [юпітер, сатурн] до 60,000; [уран, нептун] до 30,000; [земля, венера] до 6,000; [марс, ганімед, титан, ртуть, коллісто] до 3,000; [іо, місяць, європа, тритон, плутон, еріс] до 1,500; і [haumea; титанія] до 750. На жаль, отримав оцінку 117. Я побачу, чи зможу пізніше потрапити нижче 100 з альтернативним підходом.

Математика, 57 байт, оцінка = 62 58

^{-4 байти / оцінка завдяки ліртосіасту !}

#&@@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)$

Щоб знайти відповідну конфігурацію хешу, я використовував грубий форсер у C, який є частиною репо-желе .

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

Спробуйте його для всіх входів , обчисліть бал або перевірте найвищу помилку

Дуже схожа на оригінальну відповідь Олів'є. Введіть всі малі літери.

Після різних поліпшень вихідних значень найвища поточна помилка - це Венера трохи більше 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

Спробуйте або протестуйте всі матеріали

"..."Являє собою рядок , що містить багато нецензурних. Кодові точки:

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

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

Спробуйте в Інтернеті!

Якщо розділити 700000 на радіуси, ми отримаємо послідовність, яка зростає досить лінійно (хоча й доволі помилково). Приріст у таблиці нижче може бути приблизним до значень символів ASCII. Проблема такого підходу полягає в тому, що він вимагає розшифровувати вхід до значення, яке впорядковує різні імена за розміром.

Невелике питання полягає в тому, що різниця між Ерісом і Хаумеєю досить велика. Для ~~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)

Розриви рядків призначені лише для читабельності.

Введення проводиться через попередньо існуючу таблицю i з стовпчиком varchar v , згідно з нашими стандартами IO .

Приєднує таблицю введення до таблиці пам'яті на перших двох символах та повертає решта цифр x100.

Трактує "Титан" як особливий випадок, використовуючи IIF.

EDIT : Збережено 1 байт (і 1 бал), використовуючи STUFFдля видалення перших двох символів замість SUBSTRING. Дякую, t-clausen.dk!

EDIT 2 : Я хотів побачити, що станеться, якщо я спробую зберегти ще один байт, помноживши кожне значення пошуку на 99, а не на 100, і я здивував, що це насправді підвищило точність (найменш точної оцінки) !.

Це привело мене до тестування проб і помилок, а також до деяких фантазійних таблиць даних Excel, що-якщо, де я знайшов оптимальне рішення за допомогою множника 89 (що, звичайно, змінило всі мої збережені значення).

Отже, хоча це заощаджує мені лише один байт, він фактично покращує мірку на 4,6 від попереднього рішення.

EDIT 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 (<на групи з трьох символів і візьміть відповідну групу.

Ｉ⍘ ... γ

Розшифруйте результат у вигляді базового числа 95, використовуючи для друку набір символів ASCII як цифри. Приклад: Io11-й символ є I, тому ми шукаємо IIі виявляємо, що це 13-й за величиною об'єкт, і його розмір визначає, на 31який відображається 19 * 95 + 17 = 1822.

Швидкий 4 , 225 байт, оцінка = 241

Можливо, пограбуйте ще купою більше (можливо, в районі "Га-Ме-Ка"?), Але Свіфт не часто використовується (чомусь можливо.)

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

і невольф

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

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

Спробуйте в Інтернеті!

Я спробував різні "ключові розміри" для карти, але, звичайно, 1 має багато зіткнень, а використання трьох символів не дає мені i=="Titan" ?2575:17 символів, оскільки для управління "Іо" (і це займе більше 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);}

Спробуйте в Інтернеті!

Оцінка балів

Спуститися

Ім'я об'єкта перетворюється на однозначний хеш через громіздкий процес

(((*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 на основі вхідного рядка, використовуючи модифікацію @Erik рішення Python 2 Outgolfer 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

Проста програма "індекс в рядку до списку". Можна додатково пограти в гольф.

Вхід є Ansі є одним із найменувань об'єктів у великому регістрі.
Вихід є Ansі автоматично роздруковується.

Приклад:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Пояснення:
(Список радіусів та рядок імен скорочено для стислості. ...Використовується для позначення решти списку / рядка.)

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

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

Візуальна модель:

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

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

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

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

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

Ans(                                                ;Ans = 1737