Você receberá o nome de um dos 20 maiores objetos do Sistema Solar. Sua tarefa é retornar uma aproximação de seu raio, expresso em quilômetros.

Esse é um desafio de código em que sua pontuação consiste no comprimento do seu código (em bytes) multiplicado por uma taxa de penalidade , com base na sua pior aproximação. Portanto, a pontuação mais baixa vence .$\ge 1$

_{"Enquanto viajamos pelo universo" é a última linha da música Planet Caravan do Black Sabbath , também posteriormente coberta por Pantera .}

Os objetos do Sistema Solar

Fonte: Wikipedia

NB: A classificação é dada apenas para informação. A entrada é o nome do objeto.

  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

Ou como listas amigáveis ​​de copiar e colar:

'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

Sua pontuação

Seja o raio esperado do objeto e seja a resposta do seu programa para esse objeto.$R_n$$n^{th}$$A_n$

Então sua pontuação é definida como:

onde é o comprimento do seu código em bytes.$L$

Exemplo:

Se o tamanho do seu código for bytes e sua pior aproximação for na Lua com um raio estimado de km em vez de km, sua pontuação será:$100$$1000$$1737$

Quanto mais baixo, melhor.

Cabeçalho recomendado para sua resposta:

Language, 100 bytes, score = 302

Você pode usar esse script para calcular sua pontuação (primeira linha = comprimento do código, próximas 20 linhas = suas saídas, do Sun ao Titania).

Regras

• Você pode usar o nome do objeto em minúsculas, maiúsculas ou exatamente como descrito acima (maiúscula). Outros casos mistos não são permitidos.
• A entrada é garantida como um dos 20 nomes possíveis.
• Você pode retornar números inteiros ou flutuantes. Nos dois casos, a penalidade deve ser computada diretamente com esses valores (não valores arredondados no caso de flutuações).
• Você deve retornar valores positivos.
• Programas vazios não são permitidos.

PowerShell , 3 bytes, pontuação 3637

2e4

Experimente online!

Implementação muito ingênua, chata; apenas retorna, 20000não importa a entrada. Experimentar coisas como a cobertura especial do sol ou o uso de valores de ponto flutuante em vez de 2todos resultou em pontuações piores porque o tamanho do código aumentou o suficiente para compensar qualquer ganho na comparação de tamanhos.

Geléia , 34 bytes, pontuação = 37

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

A entrada está em maiúscula, a saída é a potência de 1.1 com o menor erro.

Experimente online!

Como funciona

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, pontuação = 97

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

Experimente online!

• Essa entrada usa caracteres Unicode não exibidos e de vários bytes (mas o Java os aceita, no entanto). Verifique o TIO para obter o código exato.
• A entrada deve ser maiúscula.
• Esse código arredonda os valores para o melhor múltiplo de 100 (às vezes para cima, às vezes para baixo), para que os dois últimos dígitos possam ser ignorados quando codificados, e o valor pode ser aproximado multiplicando por 100.
• Essa entrada usa vários hashes para ajustar uma string de 25 pontos de código (a menor string que eu poderia encontrar).

Créditos

• -48 pontos (-45 bytes) graças a Kevin Cruijssen , codificando os raios (divididos por 100) diretamente em um em Stringvez de codificá-los em uma intmatriz explícita .

Wolfram Language 114 103 97 88 86 82 bytes. score = 114 103 97 89 87 83 pontos

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

Pelo menos 6 pontos economizados graças a Dennis, vários mais graças a lirtosiaste mais 6 graças a user202729.

Embora o Mathematica possa buscar dados do sistema solar (assim como muitos dados astronômicos adicionais), são necessários alguns pequenos ajustes, conforme explicado abaixo.

Interpreter[#,"AstronomicalObject"]&retornará a entidade (ou seja, o objeto computável da máquina) associado ao termo representado por #.

EntityValue[AstronomicalObject[],"Radius"]retorna o raio, em milhas, da entidade. No caso de "Haumea", o valor 816,27 (ou seja, 507 * 1,61) é retornado.

Multiplicação do raio por 1.61conversões de milhas para km. Valores decimais, em vez de números inteiros, representam muito menos que 1% de erro, mesmo no caso mais extremo.

[[1]]retorna a magnitude sem a unidade, km. Mais tarde, isso foi alterado para #&@@, produzindo o mesmo resultado.

Python 3 , pontuação 95, 95 bytes

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

Experimente online!

Python 3 , pontuação 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)

Experimente online!

Powershell, 150 141 bytes, pontuação 163 153

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

Experimente online!

Script de teste:

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

Resultado:

152.731283431953 = 141 * 1.08320059171598

Explicação:

• Os nomes contêm apenas letras, os raios contêm dígitos e pontos. Assim, podemos escrever todos os dados em uma sequência de dados e realizar uma pesquisa regexp.
• O script procura todas as substrings da esquerda para a direita e obtém o último resultado encontrado.
• A entrada deve ser maiúscula para reduzir a sequência de dados.
• O end of line modeé apenas LF.

Exemplo:

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, pontuação 178

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

05AB1E , pontuação 100 66 60 ( 100 61 56 bytes )

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

Porta da resposta Java de @ OlivierGrégoire , por isso, se você gosta desta primeira resposta, certifique-se de vomitá-lo também!
Entrada em titlecase.

Verifique todos os casos de teste.

05AB1E , pontuação 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è

Entrada em minúsculas completa. Emite o raio exato, portanto, nenhuma penalidade é adicionada.

Verifique todos os casos de teste.

Explicação:

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

Consulte esta dica 05AB1E (seções Como compactar números inteiros grandes? E Como compactar cadeias de caracteres que não fazem parte do dicionário? ) Para entender como a compactação usada funciona.

Eu criei uma alternativa de 70 bytes para mapear o sol 600,000; [Júpiter, Saturno] para 60,000; [Urano, Netuno] para 30,000; [terra, Vênus] para 6,000; [Marte, Ganimedes, Titã, Mercúrio, Calisto] 3,000; [io, lua, europa, triton, plutão, eris] para 1,500; e [haumea; titania] para 750. Infelizmente, obtive uma pontuação de 117. Vou ver se consigo ficar abaixo de 100 com uma abordagem alternativa mais tarde.

Mathematica, 57 bytes, pontuação = 62 58

^{-4 bytes / score graças ao lirtosiast !}

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

Apenas faz uma pesquisa no Wolfram Alpha para o raio médio.

Gelatina , 28 bytes, pontuação = 31

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

Isso usa um hash configurável embutido que eu adicionei ao Jelly na sugestão do @ lirtosiast.

A entrada está em titlecase, a saída é a potência de 1.1 com o menor erro.

Experimente online!

Como funciona

Esta resposta consiste em apenas duas partes.

• Primeiro, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥusa o novo built-in para mapear cada uma das 20 entradas possíveis para 15 números inteiros diferentes.
• Em seguida, 1.1*eleva 1,1 à potência calculada.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘é um literal; todo caractere sem aspas é substituído pelo seu índice baseado em 0 na página de códigos de Jelly, produzindo .$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$

O hash embutido ḥprimeiro mapeia para um número inteiro incrementando cada número e, em seguida, tratando o resultado como o número inteiro básico de 250 dígitos da base bijetiva e adicionando . Isso produz .$[95, 95, 169, 55, 242]$$1$$376510639244$

Ao dividir e dividir pela metade esse número inteiro até o resultado ser , obtemos a sequência , que possui as diferenças .$0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

Em seguida, geramos 64 números inteiros de 64 bits aplicando SHAKE256-4096 à representação em seqüência de caracteres da representação interna do ḥargumento correto, e depois dividindo os 4096 bits resultantes em 64 pedaços de 64 bits.

ḥagora calcula o produto escalar das 39 diferenças e os 39 primeiros números inteiros de 64 bits gerados, módulo . Isso gera um número inteiro em .$2^{64}$$[0, 2^{64})$

A lista tem comprimento 15, então multiplicamos o número inteiro gerado por 15 e elevamos o número 64 bits do resultado. Isso gera um número inteiro em , que usamos para indexar na lista.$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$$[0, 15)$

Para encontrar a configuração de hash apropriada, usei um brute-forcer em C que faz parte do repositório Jelly .

Python 2 , 155 bytes, score = 155

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

Experimente online!

Surpreendentemente bem para esta solução preguiçosa ... procurará melhorar também. ;-)

Japt , 86 bytes, pontuação = 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

Experimente para todas as entradas , calcule a pontuação ou verifique o erro mais alto

Muito parecido com a resposta original de Olivier. A entrada está toda em minúscula.

Após várias melhorias nos valores de saída, o maior erro atual é Venus, com pouco mais de 4%.

Explicação agora que as coisas estão um pouco mais estáveis:

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

A sequência dos nomes é sujusaurneeavemagatimecaiomoeutrplerhacompactada usando a compactação interna do Japt. Os números que representam os raios são calculados da seguinte forma:

                          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, pontuação = 75

Primeira passagem para isso; Eu queria tentar uma solução de penalidade 0 para me dar uma linha de base para resolver. Voltará amanhã para ver quais melhorias podem ser feitas, espero que ainda com 0 de penalidade.

A entrada não diferencia maiúsculas de minúsculas.

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

Experimente ou teste todas as entradas

O "..."representa uma string contendo muitos não imprimíveis. Os pontos de código são:

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

Para oferecer uma explicação rápida: a sequência é dividida em partes de 2 caracteres. Em seguida, indexamos esse array usando parte da fórmula do ovs, além de alguns agrupamentos de índice e, em seguida, mapeamos os 2 caracteres para seus pontos de código.

• Guardou um byte / ponto graças a ETH

54 bytes, pontuação = 58

Um porto da solução de Olivier .

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

Teste todas as entradas

Ruby , 105 bytes, pontuação 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)}

Experimente online!

Se dividirmos 700000 pelos raios, obteremos uma sequência que aumenta razoavelmente linearmente (embora de maneira irregular). Os incrementos na tabela abaixo podem ser aproximados pelos valores ASCII dos caracteres. O problema dessa abordagem é que ela exige que a entrada seja decodificada para um valor que ordene os diferentes nomes por tamanho.

Uma questão menor é que a diferença entre Eris e Haumea é bastante grande. ~~dSão necessários três caracteres para codificar esse incremento no formato somente ASCII. A seqüência de planeta para índice possui dois espaços "planeta fantasma" para preencher o índice.

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 bytes, pontuação = 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)

Quebras de linha são apenas para legibilidade.

A entrada é obtida através da tabela preexistente i com a coluna varchar v , de acordo com nossos padrões de IO .

Une a tabela de entrada a uma tabela na memória nos dois primeiros caracteres e retorna os dígitos restantes x100.

Trata "Titan" como um caso especial usando IIF.

EDIT : Salva 1 byte (e 1 ponto) usando STUFFpara apagar os dois primeiros caracteres em vez de SUBSTRING. Obrigado, t-clausen.dk!

EDIÇÃO 2 : Queria ver o que aconteceria se tentasse salvar outro byte multiplicando cada valor de pesquisa por 99 em vez de 100 e descobri, para minha surpresa, que realmente aumentava a precisão (da estimativa menos precisa) !.

Isso me levou a alguns testes de tentativa e erro e a algumas sofisticadas tabelas de dados hipotéticos do Excel, onde encontrei uma solução ideal usando um multiplicador de 89 (que, é claro, alterou todos os meus valores armazenados).

Portanto, embora isso economize apenas um byte, ele na verdade melhora minha pontuação em 4,6 da minha solução anterior.

EDIT 3 : Pesquisou mais alto em vez de mais baixo e encontrou um fator de multiplicação ainda melhor , 198 . Os valores permanecem razoavelmente precisos enquanto diminuem minha string armazenada em alguns caracteres, o que melhora minha pontuação.

PowerShell , 203 bytes, pontuação 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]

Experimente online!

Muito semelhante à resposta de Olivier, agora que a vejo, mas desenvolvida de forma independente.

Carvão , 101 bytes, pontuação = 101

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

Experimente online! Link é a versão detalhada do código. Explicação:

⁺§θ⁰§θχ

Pegue o primeiro e o décimo primeiro caractere (ciclicamente) da sequência de entrada e concatene-os.

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

Procure-os na sequência SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTadividida em pares de caracteres.

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

Divida a sequência m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<em grupos de três caracteres e pegue o grupo correspondente.

Ｉ⍘ ... γ

Decodifique o resultado como um número base-95 usando o conjunto de caracteres ASCII imprimíveis como dígitos. Exemplo: Ioo 11º caractere é I, então procuramos IIe descobrimos que é o 13º maior objeto e seu tamanho é o 31que é mapeado 19 * 95 + 17 = 1822.

Swift 4 , 225 bytes, pontuação = 241

Provavelmente jogável com muito mais golfe (talvez na área "Ga-Me-Ca"?), Mas Swift não é frequentemente usado (por uma razão, talvez).

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

e ungolfed

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

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

Experimente Online!

Tentei diferentes "tamanhos de chave" para o mapa, mas é claro que 1 tem muitos conflitos e o uso de três caracteres não me dá i=="Titan" ?2575:17 caracteres, já que há "Io" para gerenciar (e vai demorar mais de 3 caracteres, Eu acho que).

JavaScript (ES6), 152 bytes, pontuação = 163

Bem, é uma solução bastante padrão, mas eu gostei do desafio de qualquer maneira!

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

Minha pontuação:

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

Experimente Online!

FALSO , 152 bytes, Pontuação = 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!]?

Resposta preguiçosa usando o tamanho das palavras e as primeiras letras, mas minha desculpa é que estou usando uma linguagem estranha

Experimente online! (copie, cole o código, pressione show e depois execute)

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

Meus resultados:

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 bytes, pontuação = 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);}

Experimente online!

Pontuação

Atropelar

O nome do objeto é transformado em um hash de caractere único através do processo complicado

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

cujo inchaço aponta para "Titã" / "Titânia" como os principais infratores. A inclusão do último caractere no hash foi considerada, mas isso ainda requer um strlen()em C. A primeira ocorrência do caractere de hash é pesquisada na cadeia de hash / data. Quando encontrado, o próximo caractere é utilizado e usado para aproximar o raio do objeto em questão.

O caractere de dados contém o logaritmo natural alterado e dimensionado do raio. Gerado da seguinte forma:

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

A escala foi escolhida através de tentativa e erro altamente científicos e a mudança para trazer o valor para o intervalo ASCII imprimível, evitando barras invertidas. Foi necessário algum rearranjo dos objetos na sequência devido a algumas colisões de hash / dados.

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 bytes, Pontuação = 234

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

Experimente online!

A maioria das respostas postadas parece ter usado uma estratégia de "codificação / decodificação". Gostaria de saber o quão bem eu poderia fazer, estimando o diâmetro dos corpos celestes usando uma equação simples. Foi um exercício divertido, mas a economia moderada de bytes é mais do que compensada pela penalidade de precisão.

O núcleo desta solução é a equação de estimativa:

Radius = 39**4/x**2.18

onde x é o dobro da ordem de classificação do raio do corpo.

Gero o valor de x com base na string de entrada usando uma modificação da solução Python 2 do @Erik the Outgolfer. Salvei alguns bytes no código dele reformulando minhas equações para trabalhar com [2..40] em vez de [1..20].

O código para gerar pedidos de classificação ocupa mais de 2/3 dos bytes de toda a solução. Se alguém tiver uma maneira mais compacta de gerar classificações, essa solução poderá ser reduzida ainda mais. Por causa da penalidade de precisão (em torno de 2,6), a pontuação melhoraria bastante.

Gerando a equação

Eu usei métodos estatísticos para procurar equações simples para estimar o tamanho de cada corpo com base em sua classificação. Em parte, acompanhando as idéias da solução Ruby do @Level River St e generalizando, resolvi as equações da forma:

Radius = A/(Rank)**B

Trabalhando em R, usei modelos lineares no log dos raios para desenvolver estimativas iniciais e, em seguida, usei a otimização não linear, semeando a otimização com os resultados dos modelos lineares, para procurar soluções que minimizassem a função de penalidade especificada no problema.

O valor estimado de A na equação acima é de sete dígitos, então procurei uma expressão simples para salvar alguns bytes. Procurei expressões do formulário

x**y

para dois dígitos xe 1 dígito y (para um total de cinco bytes, economizando dois bytes, ou cerca de cinco pontos, considerando a penalidade) que não era muito diferente do valor ideal de A e não inflava muito a penalidade e terminava com o (inexplicável):

39**4

TI-BASIC (TI-84), 285 bytes, Pontuação = 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

Um simples "índice na cadeia de caracteres para listar" o programa. Pode ser jogado ainda mais.

A entrada está dentro Anse é um dos nomes dos objetos em maiúsculas.
A saída está dentro Anse é impressa automaticamente.

Exemplo:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Explicação:
(A lista de raios e a sequência de nomes foram abreviadas. ...É usada para indicar o restante da lista / sequência.)

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

Modelo Visual:

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

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

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

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

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

Ans(                                                ;Ans = 1737