Вам будет дано имя одного из 20 самых больших объектов в Солнечной системе. Ваша задача - вернуть приблизительный радиус, выраженный в километрах.

Это вызов кода, где ваш счет состоит из длины вашего кода (в байтах), умноженной на коэффициент штрафа , основанный на вашем худшем приближении. Поэтому выигрывает самый низкий балл .$\ge 1$

_{«Пока мы путешествуем по вселенной» - последняя строчка песни Planet Caravan от Black Sabbath , также позже охваченной Pantera .}

Объекты Солнечной системы

Источник: Википедия

NB: ранг дан только для информации. Ввод - это имя объекта.

  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

Попробуйте онлайн!

• В этой записи используются как не отображаемые, так и многобайтовые символы Юникода (но, тем не менее, Java принимает их). Проверьте TIO для точного кода.
• Ввод должен быть в заголовке.
• Этот код округляет значения до лучших значений, кратных 100 (иногда вверх, иногда вниз), так что последние две цифры могут быть пропущены при кодировании, а затем значение может быть аппроксимировано путем умножения на 100.
• Эта запись использует различные хэши, чтобы соответствовать строке 25 кодовых точек (самая короткая строка, которую я смог найти).

кредиты

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

Wolfram Language 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 modeтолько НЧ.

Пример:

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; titania] к 750. К сожалению, он получил оценку 117. Я посмотрю, смогу ли я получить ниже 100 с альтернативным подходом позже.

Mathematica, 57 байт, оценка = 62 58

^{-4 байта / оценка благодаря lirtosiast !}

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

Просто делает Wolfram Alpha поиск среднего радиуса.

Желе , 28 байт, оценка = 31

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

При этом используется настраиваемая встроенная функция хэширования, которую я добавил в Jelly по предложению @ lirtosiast.

Входные данные указаны в заглавной букве, выходные данные - степень 1.1 с наименьшей ошибкой.

Попробуйте онлайн!

Как это устроено

Этот ответ состоит из двух частей.

• Во-первых, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥиспользуется новая встроенная функция для сопоставления каждого из 20 возможных входов с 15 различными целыми числами.
• Затем 1.1*поднимает 1,1 до вычисленной мощности.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘является буквальным; каждый символ без кавычек заменяется его индексом на основе 0 в кодовой странице Jelly, приводя к .$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$

Встроенное хэширование ḥсначала отображает в целое число, увеличивая каждое число, затем обрабатывая результат как целое целое число из 250 цифр и добавляя . Это дает .$[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-битных блока.

ḥтеперь вычисляет скалярное произведение из 39 разностей и первых 39 сгенерированных 64-битных целых чисел по модулю . Это дает целое число в .$2^{64}$$[0, 2^{64})$

Список имеет длину 15, поэтому мы умножаем сгенерированное целое число на 15 и принимаем 64 выше. биты результата. Это дает целое число в , которое мы используем для индексации в списке.$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$$[0, 15)$

Чтобы найти подходящую конфигурацию хэша, я использовал брутфорсер в C, который является частью репозитория Jelly .

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 против , в соответствии с нашими стандартами IO .

Присоединяет входную таблицу к таблице в памяти на первых двух символах и возвращает оставшиеся цифры x100.

Относится к «Титану» как к особому случаю использования IIF.

РЕДАКТИРОВАТЬ : 1 байт (и 1 балл) сохранены с помощью STUFFудаления первых двух символов вместо SUBSTRING. Спасибо, t-clausen.dk!

РЕДАКТИРОВАТЬ 2 : Я хотел посмотреть, что произойдет, если я попытаюсь сохранить еще один байт, умножив каждое значение поиска на 99 вместо 100, и обнаружил, к моему удивлению, что это на самом деле повысило точность (наименее точной оценки) !.

Это привело меня к тестированию методом проб и ошибок, а также к некоторым причудливым таблицам данных «что если» в Excel, где я нашел оптимальное решение с использованием множителя 89 (который, конечно, изменил все мои сохраненные значения).

Таким образом, хотя это спасает меня только на один байт, оно фактически улучшает мой счет на 4,6 от моего предыдущего решения.

РЕДАКТИРОВАТЬ 3 : Поиск выше, а не ниже, и нашел еще лучший коэффициент умножения, 198 . Значения остаются достаточно точными, сокращая мою сохраненную строку на несколько символов, что улучшает мой счет.

PowerShell , 203 байта, оценка 203

param($a)if($a-eq'Titan'){2575;exit}(696342,69911,58232,25362,24622,6371,6052,3390,2634,2440,2410,1822,1737,1561,1353,1186,1163,816,788)["SuJuSaUrNeEaVeMaGaMeCaIoMoEuTrPlErHaTi".indexOf(-join$a[0..1])/2]

Попробуйте онлайн!

Очень похоже на ответ Оливье, теперь, когда я его вижу, но развивалось независимо.

Древесный уголь , 101 байт, оценка = 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 (<на группы по три символа и возьмите соответствующую группу.

Ｉ⍘ ... γ

Декодируйте результат как число base-95, используя печатный набор символов ASCII в качестве цифр. Пример: Io11-й символ - это 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 имеет много столкновений, и использование трех символов не дает мне i=="Titan" ?2575:17 символов, так как есть «Io» для управления (и это займет более 3 символов, Думаю).

JavaScript (ES6), 152 байта, оценка = 163

Ну, это довольно стандартное решение, но я все равно получил удовольствие!

s=>s=='Titan'?2575:[6963,699,582,254,246,64,60,34,26,24,24,18,17,16,14,12,12,8,8]["SuJuSaUrNeEaVeMaGaMeCaIoMoEuTrPlErHaTi".match(s[0]+s[1]).index/2]*100

Моя оценка:

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

Попробуйте онлайн!

ЛОЖЬ , 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. Я сохранил несколько байтов в его коде, переписав мои уравнения для работы с [2..40] вместо [1..20].

Код для генерации порядковых рангов занимает более 2/3 байтов всего решения. Если у кого-то есть более компактный способ получения рангов, это решение может быть сокращено в дальнейшем. Из-за потери точности (около 2,6), оценка немного улучшится.

Генерация уравнения

Я использовал статистические методы для поиска простых уравнений, чтобы оценить размер каждого тела на основе его ранга. Частично развивая идеи решения Ruby @Level River St и обобщая, я остановился на уравнениях вида:

Radius = A/(Rank)**B

Работая в R, я использовал линейные модели на логах радиусов для разработки начальных оценок, а затем использовал нелинейную оптимизацию, заполняя оптимизацию результатами линейных моделей, чтобы искать решения, которые минимизировали функцию штрафа, указанную в проблема.

Расчетное значение A в приведенном выше уравнении составляет семь цифр, поэтому я искал простое выражение, чтобы сохранить пару байтов. Я искал выражения формы

x**y

для двухзначного x и однозначного 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