Ti verrà dato il nome di uno dei 20 oggetti più grandi del Sistema Solare. Il tuo compito è di restituire un'approssimazione del suo raggio, espresso in chilometri.

Questa è una sfida al codice in cui il tuo punteggio consiste nella lunghezza del tuo codice (in byte) moltiplicata per un rapporto di penalità , basato sulla tua approssimazione peggiore. Pertanto, vince il punteggio più basso .$\ge 1$

_{"Mentre viaggiamo nell'universo" è l'ultima riga della canzone Planet Caravan di Black Sabbath , anch'essa successivamente coperta da Pantera .}

Gli oggetti del sistema solare

Fonte: Wikipedia

NB: il grado è indicato a titolo puramente informativo. L'input è il nome dell'oggetto.

  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 come elenchi amichevoli copia-incolla:

'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

Il tuo punteggio

Lascia che sia il raggio atteso dell'oggetto e che sia la risposta del tuo programma per questo oggetto.$R_n$$n^{th}$$A_n$

Quindi il tuo punteggio viene definito come:

dove è la lunghezza del codice in byte.$L$

Esempio:

Se la dimensione del tuo codice è di byte e la tua approssimazione peggiore è sulla Luna con un raggio stimato di km anziché km, il tuo punteggio sarebbe:$100$$1000$$1737$

Più basso è, meglio è.

Intestazione consigliata per la tua risposta:

Language, 100 bytes, score = 302

Puoi utilizzare questo script per calcolare il tuo punteggio (prima riga = lunghezza del codice, successive 20 righe = i tuoi risultati, da Sun a Titania).

Regole

• Puoi prendere il nome dell'oggetto in minuscolo, maiuscolo o esattamente come descritto sopra (custodia del titolo). Non sono ammessi altri casi misti.
• L'ingresso è garantito per essere uno dei 20 nomi possibili.
• È possibile restituire numeri interi o float. In entrambi i casi, la penalità deve essere calcolata direttamente con questi valori (valori non arrotondati in caso di float).
• È necessario restituire valori positivi.
• Non sono consentiti programmi vuoti.

PowerShell , 3 byte, punteggio 3637

2e4

Provalo online!

Realizzazione molto ingenua, noiosa; restituisce semplicemente 20000indipendentemente dall'input. La sperimentazione di cose come il caso speciale del sole o l'uso di valori in virgola mobile invece di 2tutti ha portato a punteggi peggiori perché la lunghezza del codice è aumentata abbastanza da compensare eventuali guadagni di confronto delle dimensioni.

Gelatina , 34 byte, punteggio = 37

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

L'input è in maiuscolo, l'output è la potenza di 1.1 con il minimo errore.

Provalo online!

Come funziona

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 byte, punteggio = 97

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

Provalo online!

• Questa voce utilizza sia caratteri Unicode non visualizzabili che multi-byte (ma Java li accetta comunque). Controllare il TIO per il codice esatto.
• L'input deve essere case del titolo.
• Questo codice arrotonda i valori al miglior multiplo di 100 (a volte in alto, a volte in basso) in modo che le ultime due cifre possano essere saltate quando codificate e che il valore possa quindi essere approssimato moltiplicando per 100.
• Questa voce utilizza vari hash per adattare una stringa di 25 punti di codice (la stringa più corta che ho trovato).

Crediti

• -48 punteggio (-45 byte) grazie a Kevin Cruijssen codificando i raggi (divisi per 100) direttamente in un Stringinvece di codificarli in un intarray esplicito .

Lingua Wolfram 114 103 97 88 86 82 byte. punteggio = 114 103 97 89 87 83 punti

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

Almeno 6 punti risparmiati grazie a Dennis, molti altri grazie a lirtosiaste altri 6 grazie a user202729.

Sebbene Mathematica sia in grado di recuperare i dati del sistema solare (oltre a molti altri dati astronomici), sono necessarie alcune piccole modifiche, come spiegato di seguito.

Interpreter[#,"AstronomicalObject"]&restituirà l'entità (ovvero l'oggetto calcolabile dalla macchina) associata al termine rappresentato da #.

EntityValue[AstronomicalObject[],"Radius"]restituisce il raggio, in miglia, dell'entità. Nel caso di "Haumea", viene restituito il valore, 816,27 (ovvero 507 * 1,61).

Moltiplicazione del raggio per 1.61convertiti da miglia a km. I valori decimali, anziché i numeri interi, rappresentano un errore molto inferiore all'1%, anche nel caso più estremo.

[[1]]restituisce la grandezza senza l'unità, km. Questo è stato successivamente modificato in #&@@, ottenendo lo stesso risultato.

Python 3 , punteggio 95, 95 byte

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

Provalo online!

Python 3 , punteggio 133, 133 byte

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)

Provalo online!

Powershell, 150 141 byte, punteggio 163 153

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

Provalo online!

Script di prova:

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

Produzione:

152.731283431953 = 141 * 1.08320059171598

Spiegazione:

• I nomi contengono solo lettere, i raggi contengono cifre e punti. Quindi possiamo scrivere tutti i dati in una stringa di dati ed eseguire una ricerca regexp.
• Lo script cerca tutte le sottostringhe da sinistra a destra e prende l'ultimo risultato trovato.
• L'input deve essere case del titolo per ridurre la stringa di dati.
• È end of line modesolo LF.

Esempio:

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 byte, punteggio 178

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

05AB1E , punteggio 100 66 60 ( 100 61 56 byte )

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

La risposta Java di Port of @ OlivierGrégoire , quindi se ti piace questa prima risposta, assicurati di votare anche lui!
Immettere in titlecase.

Verifica tutti i casi di test.

05AB1E , punteggio 100 (100 byte )

•*Òâ%ÌÜS…Ùb‹Úi{e!]ɸ·vÌBUSηHã£āðxyµŠ•§•3«8¹ØмS7Ç•S£.•WùηƵ@,Sº,ûεβʒóÃX\¹Θäáá’Ý)”Ωož∞-z.A±D•3ôI2£Iθ«kè

Inserire in minuscolo. Emette il raggio esatto, quindi non viene aggiunta alcuna penalità.

Verifica tutti i casi di test.

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezioni Come comprimere numeri interi grandi? E Come comprimere le stringhe che non fanno parte del dizionario? ) Per capire come funziona la compressione utilizzata.

Ho creato un'alternativa di 70 byte a cui mappare il sole 600,000; [Giove, Saturno] a 60,000; [urano, nettuno] a 30,000; [terra, venere] a 6,000; [Marte, Ganimede, Titano, Mercurio, Callisto] a 3,000; [io, moon, europa, triton, pluto, eris] a 1,500; e [haumea; titania] a 750. Purtroppo ho ottenuto un punteggio di 117. Vedrò se riesco a scendere sotto i 100 con un approccio alternativo in seguito.

Mathematica, 57 byte, punteggio = 62 58

^{-4 byte / punteggio grazie a lirtosiast !}

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

Fa solo una ricerca Wolfram Alpha per il raggio medio.

Gelatina , 28 byte, punteggio = 31

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

Questo utilizza un hashing configurabile integrato che ho aggiunto a Jelly su suggerimento di @lirtosiast.

L'input è in titlecase, l'output è la potenza di 1.1 con il minimo errore.

Provalo online!

Come funziona

Questa risposta è composta da due sole parti.

• Innanzitutto, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥutilizza il nuovo built-in per mappare ciascuno dei 20 possibili input a 15 interi diversi.
• Quindi, 1.1*eleva 1.1 alla potenza calcolata.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$

ḥ$[95, 95, 169, 55, 242]$$1$$376510639244$

$0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

Successivamente, generiamo 64 numeri interi a 64 bit applicando SHAKE256-4096 alla rappresentazione in formato stringa della rappresentazione interna ḥdell'argomento destro, quindi tagliando i 4096 bit risultanti in blocchi di 64 bit a 64 bit.

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

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

Per trovare la configurazione hash appropriata, ho usato un bruto-forcer in C che fa parte del repository Jelly .

Python 2 , 155 byte, punteggio = 155

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

Provalo online!

Sorprendentemente bene per questa soluzione pigra ... cercherà anche di migliorare. ;-)

Japt , 86 byte, punteggio = 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

Provalo per tutti gli input , calcola il punteggio o controlla l'errore più alto

Molto simile alla risposta originale di Olivier. L'input è tutto minuscolo.

Dopo vari miglioramenti ai valori di output, l'attuale errore più elevato è Venere di poco più del 4%.

Spiegazione ora che le cose sono un po 'più stabili:

¤¥`É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 stringa per i nomi viene sujusaurneeavemagatimecaiomoeutrplerhacompressa utilizzando la compressione integrata di Japt. I numeri che rappresentano i raggi sono calcolati in questo modo:

                          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 byte, punteggio = 75

Primo passaggio a questo; Volevo provare una soluzione di penalità 0 per darmi una base per lavorare. Ci torneremo domani per vedere quali miglioramenti possono essere fatti, speriamo ancora per 0 penalità.

L'input non fa distinzione tra maiuscole e minuscole.

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

Provalo o prova tutti gli ingressi

Il "..."rappresenta una stringa contenente molti non stampabili. I punti di codice sono:

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

Per offrire una rapida spiegazione: la stringa viene suddivisa in blocchi di 2 caratteri. Quindi indicizziamo in quell'array usando parte della formula di ovs più un po 'di wrapping dell'indice e quindi mappiamo i 2 caratteri ai loro punti di codice.

• Salvataggio di un byte / punto grazie a ETH

54 byte, punteggio = 58

Un porto della soluzione di Olivier .

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

Prova tutti gli input

Rubino , 105 byte, punteggio 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)}

Provalo online!

Se dividiamo 700000 per i raggi, otteniamo una sequenza che aumenta ragionevolmente linearmente (sebbene piuttosto in modo irregolare). Gli incrementi nella tabella seguente possono essere approssimati dai valori ASCII dei caratteri. Il problema con questo approccio è che richiede che l'input sia decodificato in un valore che ordina i diversi nomi per dimensione.

Un problema minore è che la differenza tra Eris e Haumea è piuttosto grande. Sono ~~dnecessari tre caratteri per codificare questo incremento in formato solo ASCII. La stringa da pianeta a indice ha due spazi "pianeta fantasma" al suo interno per riempire l'indice.

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 byte, punteggio = 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)

Le interruzioni di riga sono solo per leggibilità.

L'input viene preso tramite la tabella i preesistente con la colonna varchar v , secondo i nostri standard IO .

Unisce la tabella di input a una tabella in memoria dei primi due caratteri e restituisce le cifre rimanenti x100.

Tratta "Titan" come un caso speciale usando IIF.

EDIT : salvato 1 byte (e 1 punto) usando STUFFper cancellare i primi due caratteri invece di SUBSTRING. Grazie, t-clausen.dk!

EDIT 2 : Volevo vedere cosa sarebbe successo se avessi cercato di salvare un altro byte moltiplicando ogni valore di ricerca per 99 anziché 100, e ho scoperto con mia sorpresa che in realtà aumentava l'accuratezza (della stima meno accurata) !.

Questo mi ha portato ad alcuni test di prova ed errore, e ad alcune fantasiose tabelle di dati what-if di Excel, in cui ho trovato una soluzione ottimale usando un moltiplicatore di 89 (che ovviamente ha cambiato tutti i miei valori memorizzati).

Quindi, mentre questo mi fa risparmiare solo un byte, in realtà migliora il mio punteggio di 4,6 rispetto alla mia soluzione precedente.

EDIT 3 : cercato più in alto invece che in basso, e ha trovato un fattore di moltiplicazione ancora migliore , 198 . I valori rimangono ragionevolmente precisi mentre accorciano la mia stringa memorizzata di parecchi caratteri, il che migliora il mio punteggio.

PowerShell , 203 byte, punteggio 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]

Provalo online!

Molto simile alla risposta di Olivier, ora che la vedo, ma sviluppata indipendentemente.

Carbone , 101 byte, punteggio = 101

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

⁺§θ⁰§θχ

Prendi il primo e l'undicesimo carattere (ciclicamente) della stringa di input e concatenali.

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

Cercali nella stringa SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTadivisa in coppie di caratteri.

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

Dividi la stringa m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<in gruppi di tre caratteri e prendi il gruppo corrispondente.

Ｉ⍘ ... γ

Decodifica il risultato come numero base-95 utilizzando il set di caratteri ASCII stampabile come cifre. Esempio: Iol'undicesimo personaggio è I, quindi guardiamo in alto IIe scopriamo che è il 13 ° oggetto più grande e la sua dimensione è quella su 31cui è mappata 19 * 95 + 17 = 1822.

Swift 4 , 225 byte, punteggio = 241

Probabilmente il golf un po 'di più (forse nell'area "Ga-Me-Ca"?), Ma Swift non viene spesso usato (per un motivo, forse.)

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

Provalo online!

Ho provato diverse "dimensioni chiave" per la mappa, ma ovviamente 1 ha molti scontri e l'utilizzo di tre caratteri non mi dà i=="Titan" ?2575:i 17 caratteri, poiché c'è "Io" da gestire (e ci vorranno più di 3 caratteri, Penso).

JavaScript (ES6), 152 byte, punteggio = 163

Bene, è una soluzione piuttosto standard, ma la sfida mi è piaciuta comunque!

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

Il mio punteggio:

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

Provalo online!

FALSO , 152 byte, punteggio = 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!]?

Risposta pigra usando la lunghezza delle parole e le prime lettere ma la mia scusa è che sto usando una lingua strana

Provalo online! (copia incolla il codice, premi show ed esegui)

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

I miei risultati:

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 byte, punteggio = 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);}

Provalo online!

punteggio

Corri giù

Il nome dell'oggetto viene trasformato in un hash a carattere singolo attraverso il processo ingombrante

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

il cui gonfiore indica "Titan" / "Titania" come i principali trasgressori. È stato considerato l'inclusione dell'ultimo carattere nell'hash, ma ciò richiede ancora un carattere strlen()in C. La prima occorrenza del carattere hash viene cercata nella stringa hash / data. Quando viene trovato, il carattere successivo viene preso e utilizzato per approssimare il raggio dell'oggetto in questione.

Il carattere dei dati contiene il logaritmo naturale spostato e scalato del raggio. Generato così:

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

La scala è stata scelta attraverso prove ed errori altamente scientifici e lo spostamento per portare il valore all'interno dell'intervallo ASCII stampabile evitando le barre rovesciate. Un certo riarrangiamento degli oggetti nella stringa era necessario a causa di alcune collisioni di hash / dati.

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 byte, Punteggio = 234

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

Provalo online!

La maggior parte delle risposte pubblicate sembra aver utilizzato una strategia di "codifica / decodifica". Mi chiedevo quanto avrei potuto fare stimando il diametro dei corpi celesti usando una semplice equazione. È stato un esercizio divertente, ma i moderati risparmi di byte sono più che compensati dalla penalità di precisione.

Il nucleo di questa soluzione è l'equazione di stima:

Radius = 39**4/x**2.18

dove x è il doppio dell'ordine di rango del raggio del corpo.

Genero il valore di x in base alla stringa di input usando una modifica di @Erik la soluzione Python 2 di Outgolfer. Ho salvato alcuni byte sul suo codice riformulando le mie equazioni per lavorare con [2..40] anziché [1..20].

Il codice per la generazione di ordini di classificazione occupa più di 2/3 dei byte dell'intera soluzione. Se qualcuno ha un modo più compatto di generare ranghi, questa soluzione potrebbe essere ulteriormente abbreviata. A causa della penalità di precisione (circa 2,6), il punteggio migliorerebbe un po '.

Generare l'equazione

Ho usato metodi statistici per cercare equazioni semplici per stimare le dimensioni di ciascun corpo in base al suo rango. In parte dando seguito alle intuizioni della soluzione Ruby di @Level River St e generalizzando, ho optato per le equazioni del modulo:

Radius = A/(Rank)**B

Lavorando in R, ho usato modelli lineari sul registro dei raggi per sviluppare stime iniziali, quindi ho usato l'ottimizzazione non lineare, seminando l'ottimizzazione con i risultati dei modelli lineari, per cercare soluzioni che minimizzassero la funzione di penalità specificata nella problema.

Il valore stimato di A nell'equazione precedente è di sette cifre, quindi ho cercato un'espressione semplice per salvare un paio di byte. Ho cercato espressioni del modulo

x**y

per due cifre xe 1 cifra y (per un totale di cinque byte, risparmiando due byte o circa cinque punti, considerata la penalità) che non era troppo diverso dal valore ottimale di A e non gonfiava molto la penalità, e si è concluso con (altrimenti inspiegabile):

39**4

TI-BASIC (TI-84), 285 byte, Punteggio = 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 semplice programma "indice nella stringa da elencare". Può essere ulteriormente giocato a golf.

L'input è in Ansed è uno dei nomi degli oggetti in maiuscolo.
L'output è attivo Anse viene stampato automaticamente.

Esempio:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Spiegazione:
(l'elenco Radii e la stringa del nome sono stati abbreviati per brevità. ...Viene utilizzato per indicare il resto dell'elenco / stringa.)

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

Modello visivo:

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