Se le dará el nombre de uno de los 20 objetos más grandes del Sistema Solar. Su tarea es devolver una aproximación de su radio, expresada en kilómetros.

Este es un desafío de código donde su puntaje consiste en la longitud de su código (en bytes) multiplicado por una relación de penalización , según su peor aproximación. Por lo tanto, gana el puntaje más bajo .$\ge 1$

_{"A medida que viajamos por el universo" es la última línea de la canción Planet Caravan de Black Sabbath , también más tarde cubierta por Pantera .}

Los objetos del sistema solar

Fuente: Wikipedia

NB: El rango se otorga solo para información. La entrada es el nombre del 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

O como listas amigables para copiar y pegar:

'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

Tu puntuación

Deje que sea ​​el radio esperado del objeto y deje que sea ​​la respuesta de su programa para este objeto.$R_n$$n^{th}$$A_n$

Entonces su puntaje se define como:

donde es la longitud de su código en bytes.$L$

Ejemplo:

Si el tamaño de su código es de bytes y su peor aproximación está en la Luna con un radio estimado de km en lugar de km, entonces su puntaje sería:$100$$1000$$1737$

Cuanto más bajo, mejor.

Encabezado recomendado para su respuesta:

Language, 100 bytes, score = 302

Puede usar este script para calcular su puntaje (primera línea = longitud del código, siguientes 20 líneas = sus salidas, desde Sun hasta Titania).

Reglas

• Puede tomar el nombre del objeto en minúsculas, mayúsculas o exactamente como se describe anteriormente (título del caso). No se permiten otros casos mixtos.
• La entrada está garantizada como uno de los 20 nombres posibles.
• Puede devolver enteros o flotantes. En ambos casos, la penalización debe calcularse directamente con estos valores (no valores redondeados en caso de flotadores).
• Debes devolver valores positivos.
• Los programas vacíos no están permitidos.

PowerShell , 3 bytes, puntaje 3637

2e4

Pruébalo en línea!

Muy ingenuo, aburrido, implementación; solo regresa 20000sin importar la entrada. La experimentación con cosas como la protección especial del sol o el uso de valores de punto flotante en lugar de 2todos dio como resultado puntajes peores porque la longitud del código aumentó lo suficiente como para compensar cualquier ganancia de comparación de tamaños.

Gelatina , 34 bytes, puntaje = 37

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

La entrada está en mayúscula, la salida es la potencia de 1.1 con el menor error.

Pruébalo en línea!

Cómo 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, puntaje = 97

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

Pruébalo en línea!

• Esta entrada utiliza caracteres Unicode no visualizables y de varios bytes (sin embargo, Java los acepta). Verifique el TIO para el código exacto.
• La entrada debe ser case-title.
• Este código redondea los valores al mejor múltiplo de 100 (a veces hacia arriba, a veces hacia abajo) para que los últimos dos dígitos se puedan omitir cuando se codifican, y el valor se puede aproximar multiplicando por 100.
• Esta entrada usa varios hashes para ajustar una cadena de 25 puntos de código (la cadena más corta que pude encontrar).

Créditos

• -48 puntaje (-45 bytes) gracias a Kevin Cruijssen al codificar los radios (divididos por 100) directamente en Stringlugar de codificarlos en una intmatriz explícita .

Wolfram Language 114103 97 88 86 82 bytes. puntaje = 114103 97 89 87 83 puntos

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

Al menos 6 puntos guardados gracias a Dennis, varios más gracias a lirtosiast, y 6 más gracias a user202729.

Aunque Mathematica puede obtener datos del sistema solar (así como muchos datos astronómicos adicionales), se necesitan algunos ajustes menores, como se explica a continuación.

Interpreter[#,"AstronomicalObject"]&devolverá la entidad (es decir, el objeto computable de la máquina) asociada con el término representado por #.

EntityValue[AstronomicalObject[],"Radius"]devuelve el radio, en millas, de la entidad. En el caso de "Haumea", se devuelve el valor 816.27 (es decir, 507 * 1.61).

Multiplicación del radio por 1.61conversiones de millas a km. Los valores decimales, en lugar de los enteros, representan mucho menos del 1% de error, incluso en el caso más extremo.

[[1]]devuelve la magnitud sin la unidad, km. Esto luego se cambió a #&@@, dando el mismo resultado.

Python 3 , puntaje 95, 95 bytes

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

Pruébalo en línea!

Python 3 , puntaje 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)

Pruébalo en línea!

Powershell, 150 141 bytes, la puntuación de 163 153

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

Pruébalo en línea!

Script de prueba:

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

Salida:

152.731283431953 = 141 * 1.08320059171598

Explicación:

• Los nombres contienen solo letras, los radios contienen dígitos y puntos. Entonces podemos escribir todos los datos en una cadena de datos y realizar una búsqueda de expresiones regulares.
• El script busca todas las subcadenas de izquierda a derecha y toma el último resultado encontrado.
• La entrada debe ser case-title para reducir la cadena de datos.
• El end of line modees solo LF.

Ejemplo:

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, puntaje 178

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

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

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

Puerto de la respuesta Java de @ OlivierGrégoire , así que si te gusta esta primera respuesta, ¡asegúrate de votarlo también!
Entrada en titlecase.

Verifique todos los casos de prueba.

05AB1E , puntaje 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 en minúscula completa. Emite el radio exacto, por lo que no se agrega penalización.

Verifique todos los casos de prueba.

Explicación:

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

Vea esta sugerencia mía 05AB1E (secciones ¿Cómo comprimir enteros grandes? Y ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender cómo funciona la compresión utilizada.

Creé una alternativa de 70 bytes que mapearía sun 600,000; [Júpiter, Saturno] a 60,000; [Urano, Neptuno] a 30,000; [tierra, venus] a 6,000; [Marte, Ganímedes, Titán, Mercurio, Calisto] a 3,000; [io, luna, europa, tritón, plutón, eris] a 1,500; y [haumea; titania] a 750. Desafortunadamente eso obtuvo un puntaje de 117. Veré si puedo llegar a menos de 100 con un enfoque alternativo más adelante.

Mathematica, 57 bytes, puntaje = 62 58

^{-4 bytes / puntuación gracias a lirtosiast !}

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

Simplemente realiza una búsqueda Wolfram Alpha para el radio medio.

Gelatina , 28 bytes, puntaje = 31

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

Esto utiliza un hashing configurable incorporado que agregué a Jelly por sugerencia de @ lirtosiast.

La entrada está en el título, la salida es la potencia de 1.1 con el menor error.

Pruébalo en línea!

Cómo funciona

Esta respuesta consta simplemente de dos partes.

• Primero, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥusa el nuevo incorporado para mapear cada una de las 20 entradas posibles a 15 enteros diferentes.
• Luego, 1.1*eleva 1.1 a la potencia calculada.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘es un literal; cada carácter sin comillas se reemplaza por su índice basado en 0 en la página de códigos de Jelly, dando .$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$

El hash incorporado ḥprimero asigna a un número entero incrementando cada número, luego trata el resultado como el número entero de 250 dígitos de base biyectiva y suma . Esto produce .$[95, 95, 169, 55, 242]$$1$$376510639244$

Al dividir en dos este número entero hasta obtener el resultado , obtenemos la secuencia , que tiene las diferencias hacia adelante .$0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

A continuación, generamos 64 enteros de 64 bits aplicando SHAKE256-4096 a la representación de cadena de la representación interna del ḥargumento correcto de '' '', luego cortamos los 4096 bits resultantes en 64 fragmentos de 64 bits.

ḥahora calcula el producto punto de las 39 diferencias y los primeros 39 enteros de 64 bits generados, módulo . Esto produce un número entero en .$2^{64}$$[0, 2^{64})$

La lista tiene una longitud de 15, por lo que multiplicamos el entero generado por 15 y tomamos el 64 más alto bits del resultado. Esto produce un número entero en , que usamos para indexar en la lista.$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$$[0, 15)$

Para encontrar la configuración de hash adecuada, he usado un forzador de brutas en C que forma parte del repositorio de Jelly .

Python 2 , 155 bytes, puntaje = 155

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

Pruébalo en línea!

Sorprendentemente bien para esta solución perezosa ... buscará mejorar también. ;-)

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

Pruébelo para todas las entradas , calcule la puntuación o compruebe el error más alto

Muy similar a la respuesta original de Olivier. La entrada es todo en minúsculas.

Después de varias mejoras en los valores de salida, el error más alto actual es Venus con un poco más del 4%.

Explicación ahora que las cosas son un poco más estables:

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

La cadena de los nombres se sujusaurneeavemagatimecaiomoeutrplerhacomprime utilizando la compresión integrada de Japt. Los números que representan los radios se calculan así:

                          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, puntaje = 75

Primer paso en esto; Quería probar una solución de penalización 0 para darme una línea de base para trabajar. Regresaremos mañana para ver qué mejoras se pueden hacer, con suerte aún para 0 penalizaciones.

La entrada no distingue entre mayúsculas y minúsculas.

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

Pruébalo o prueba todas las entradas

El "..."representa una cadena que contiene muchos no imprimibles. Los puntos de código son:

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 ofrecer una explicación rápida: la cadena se divide en trozos de 2 caracteres. Luego indexamos en esa matriz usando parte de la fórmula de ovs más un ajuste de índice y luego asignamos los 2 caracteres a sus puntos de código.

• Guardado un byte / punto gracias a ETH

54 bytes, puntuación = 58

Un puerto de la solución de Olivier .

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

Probar todas las entradas

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

Pruébalo en línea!

Si dividimos 700000 por los radios, obtenemos una secuencia que aumenta de manera razonablemente lineal (aunque bastante errática). Los incrementos en la tabla a continuación pueden ser aproximados por los valores ASCII de los caracteres. El problema con este enfoque es que requiere que la entrada se decodifique a un valor que ordene los diferentes nombres por tamaño.

Un problema menor es que la diferencia entre Eris y Haumea es bastante grande. Se ~~drequieren tres caracteres para codificar este incremento en formato ASCII solamente. La cadena de planeta a índice tiene dos espacios de "planeta fantasma" para rellenar el í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, puntaje = 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)

Los saltos de línea son solo para legibilidad.

La entrada se toma a través de la tabla i existente con la columna varchar v , según nuestros estándares IO .

Une la tabla de entrada a una tabla en memoria en los dos primeros caracteres y devuelve los dígitos restantes x100.

Trata a "Titán" como un caso especial usando IIF.

EDITAR : guardado 1 byte (y 1 punto) al usar STUFFpara borrar los dos primeros caracteres en lugar de SUBSTRING. Gracias, t-clausen.dk!

EDIT 2 : ¡Quería ver qué pasaría si intentara guardar otro byte multiplicando cada valor de búsqueda por 99 en lugar de 100, y descubrí para mi sorpresa que en realidad aumentó la precisión (¡la estimación menos precisa!).

Esto me llevó a algunas pruebas de prueba y error, y a algunas tablas de datos de Excel que sucedieron, donde encontré una solución óptima usando un multiplicador de 89 (que por supuesto cambió todos mis valores almacenados).

Entonces, aunque esto me ahorra solo un byte, en realidad mejora mi puntaje en 4.6 de mi solución anterior.

EDITAR 3 : busqué más alto en lugar de más bajo, y encontré un factor de multiplicación aún mejor , 198 . Los valores se mantienen razonablemente precisos mientras acortan mi cadena almacenada en bastantes caracteres, lo que mejora mi puntaje.

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

Pruébalo en línea!

Muy similar a la respuesta de Olivier, ahora que lo veo, pero se desarrolló de forma independiente.

Carbón , 101 bytes, puntaje = 101

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

⁺§θ⁰§θχ

Tome el primer y undécimo carácter (cíclicamente) de la cadena de entrada y concatenelos.

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

Búscalos en la cadena SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTadividida en pares de caracteres.

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

Divide la cadena m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<en grupos de tres caracteres y toma el grupo correspondiente.

Ｉ⍘ ... γ

Decodifique el resultado como un número base-95 utilizando el juego de caracteres ASCII imprimible como dígitos. Ejemplo: Ioel undécimo carácter es I, así que miramos hacia arriba IIy encontramos que es el decimotercer objeto más grande y su tamaño es el 31que se asigna 19 * 95 + 17 = 1822.

Swift 4 , 225 bytes, puntaje = 241

Probablemente golfa un montón más (¿tal vez en el área "Ga-Me-Ca"?), Pero Swift no se usa a menudo (por alguna razón, tal vez).

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

y sin golf

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

¡Pruébelo en línea!

Intenté diferentes "tamaños de clave" para el mapa, pero, por supuesto, 1 tiene muchos enfrentamientos y el uso de tres caracteres no me da i=="Titan" ?2575:los 17 caracteres, ya que hay "Io" para administrar (y tomará más de 3 caracteres, Yo creo que).

JavaScript (ES6), 152 bytes, puntuación = 163

Bueno, es una solución bastante estándar, ¡pero disfruté el desafío de todos modos!

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

Mi puntaje:

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

Pruébalo en línea!

FALSO , 152 bytes, Puntuación = 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!]?

Respuesta perezosa usando palabras largas y primeras letras, pero mi excusa es que estoy usando un lenguaje extraño

Pruébalo en línea! (copie y pegue el código, presione mostrar y luego ejecute)

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

Mis 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, puntaje = 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);}

Pruébalo en línea!

Puntuación

Atropellar

El nombre del objeto se convierte en un hash de un solo carácter a través del proceso engorroso

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

cuya hinchazón apunta a "Titán" / "Titania" como los principales delincuentes. Se consideró incluir el último carácter en el hash, pero eso todavía requiere una strlen()en C. La primera aparición del carácter de hash se busca en la cadena de hash / datos. Cuando se encuentra, se toma el siguiente carácter y se usa para aproximar el radio del objeto en cuestión.

El carácter de datos contiene el logaritmo natural desplazado y escalado del radio. Generado así:

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

La escala se eligió mediante prueba y error altamente científica, y el cambio para poner el valor dentro del rango ASCII imprimible y evitar las barras diagonales inversas. Fue necesario reorganizar los objetos en la cadena debido a algunas colisiones de hash / datos.

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, Puntuación = 234

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

Pruébalo en línea!

La mayoría de las respuestas publicadas parecen haber utilizado una estrategia de "codificación / decodificación". Me preguntaba qué tan bien podría hacerlo estimando el diámetro de los cuerpos celestes usando una ecuación simple. Ha sido un ejercicio divertido, pero el ahorro moderado de bytes está más que compensado por la penalización de precisión.

El núcleo de esta solución es la ecuación de estimación:

Radius = 39**4/x**2.18

donde x es dos veces el orden de rango del radio del cuerpo.

Genero el valor de x basado en la cadena de entrada usando una modificación de @Erik la solución Python 2 de Outgolfer. Ahorré algunos bytes en su código al cambiar mis ecuaciones para trabajar con [2..40] en lugar de [1..20].

El código para generar órdenes de rango ocupa más de 2/3 de los bytes de la solución completa. Si alguien tiene una forma más compacta de generar rangos, esta solución podría acortarse aún más. Debido a la penalización de precisión (alrededor de 2.6), la puntuación mejoraría bastante.

Generando la ecuación

Utilicé métodos estadísticos para buscar ecuaciones simples para estimar el tamaño de cada cuerpo en función de su rango. En parte, siguiendo las ideas de la solución Ruby de @Level River St y generalizando, me decidí por ecuaciones de la forma:

Radius = A/(Rank)**B

Trabajando en R, utilicé modelos lineales en el registro de los radios para desarrollar estimaciones iniciales, y luego utilicé la optimización no lineal, sembrando la optimización con los resultados de los modelos lineales, para buscar soluciones que minimizaran la función de penalización especificada en el problema.

El valor estimado de A en la ecuación anterior es de siete dígitos, por lo que busqué una expresión simple para guardar un par de bytes. Busqué expresiones de la forma

x**y

para dos dígitos xy 1 dígito y (para un total de cinco bytes, ahorrando dos bytes, o aproximadamente cinco puntos, dada la penalización) que no fue muy diferente del valor óptimo de A y no infló mucho la penalización, y terminó con el (de lo contrario inexplicable):

39**4

TI-BASIC (TI-84), 285 bytes, Puntuación = 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

Un programa simple de "índice en cadena para listar". Se puede jugar más al golf.

La entrada está en Ansy es uno de los nombres de los objetos en mayúscula completa.
La salida está enAns y se imprime automáticamente.

Ejemplo:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Explicación:
(La lista de radios y la cadena de nombre se han acortado por brevedad. ...Se utiliza para indicar el resto de la lista / cadena).

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