Vous recevrez le nom d’un des 20 plus gros objets du système solaire. Votre tâche consiste à renvoyer une approximation de son rayon, exprimée en kilomètres.

Il s’agit d’un défi de code dans lequel votre score est composé de la longueur de votre code (en octets) multipliée par un ratio de pénalité , basé sur votre pire approximation. Par conséquent, le score le plus bas gagne .$\ge 1$

_{"En parcourant l'univers" est la dernière ligne de la chanson Planet Caravan de Black Sabbath , également reprise plus tard par Pantera .}

Les objets du système solaire

Source: Wikipedia

NB: Le classement est donné à titre indicatif. L'entrée est le nom de l'objet.

  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 sous forme de listes copiées-copiées:

'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

Ton score

Soit $R_n$ le rayon attendu de l'objet , et la réponse de votre programme pour cet objet.$n^{th}$$A_n$

Ensuite, votre score est défini comme:

où est la longueur de votre code en octets.$L$

Exemple:

Si la taille de votre code est de octets et que votre pire approximation est celle de la Lune avec un rayon estimé à km au lieu de km, votre score serait alors:$100$$1000$$1737$

Le plus bas, mieux c'est.

En-tête recommandé pour votre réponse:

Language, 100 bytes, score = 302

Vous pouvez utiliser ce script pour calculer votre score (première ligne = longueur du code, 20 lignes suivantes = vos sorties, de Sun à Titania).

Règles

• Vous pouvez prendre le nom de l'objet en minuscule, en majuscule ou exactement comme décrit ci-dessus (cas du titre). Les autres cas mixtes ne sont pas autorisés.
• L'entrée est garantie d'être l'un des 20 noms possibles.
• Vous pouvez renvoyer des nombres entiers ou des flottants. Dans les deux cas, la pénalité doit être calculée directement avec ces valeurs (pas des valeurs arrondies dans le cas de floats).
• Vous devez retourner des valeurs positives.
• Les programmes vides ne sont pas autorisés.

PowerShell , 3 octets, score 3637

2e4

Essayez-le en ligne!

Très naïf, ennuyeux, mise en oeuvre; retourne 20000peu importe l'entrée. Des expériences avec des cas comme le soleil spécial ou l'utilisation de valeurs en virgule flottante au lieu de 2toutes ont eu pour résultat des scores pires, car la longueur du code a augmenté suffisamment pour compenser les gains de comparaison de taille.

Gelée , 34 octets, score = 37

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

L'entrée est en majuscule, la sortie est la puissance de 1.1 avec la moindre erreur.

Essayez-le en ligne!

Comment ça fonctionne

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 octets, score = 97

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

Essayez-le en ligne!

• Cette entrée utilise des caractères Unicode non lisibles et multi-octets (mais Java les accepte néanmoins). Vérifiez le TIO pour le code exact.
• L'entrée doit être la casse du titre.
• Ce code arrondit les valeurs au meilleur multiple de 100 (parfois haut, parfois bas) afin que les deux derniers chiffres puissent être ignorés lors du codage, et que la valeur puisse ensuite être approximée en multipliant par 100.
• Cette entrée utilise divers hachages pour adapter une chaîne de 25 points de codage (la chaîne la plus courte que j'ai pu trouver).

Crédits

• -48 score (-45 octets) grâce à Kevin Cruijssen en encodant les rayons (divisés par 100) directement dans un Stringfichier au lieu de les coder en dur dans un inttableau explicite .

Wolfram Language 114 103 97 88 86 82 octets. score = 114 103 97 89 87 83 points

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

Au moins 6 points économisés grâce à Dennis, plusieurs autres grâce lirtosiastet 6 autres grâce à user202729.

Bien que Mathematica puisse extraire des données du système solaire (ainsi que de nombreuses données astronomiques supplémentaires), quelques ajustements mineurs sont nécessaires, comme expliqué ci-dessous.

Interpreter[#,"AstronomicalObject"]&renverra l'entité (c'est-à-dire l'objet informatique de la machine) associée au terme représenté par #.

EntityValue[AstronomicalObject[],"Radius"]renvoie le rayon, en miles, de l'entité. Dans le cas de "Haumea", la valeur 816.27 (c'est-à-dire 507 * 1.61) est renvoyée.

La multiplication du rayon par 1.61convertit des miles en km. Les valeurs décimales, plutôt que les entiers, représentent beaucoup moins d'erreurs que 1%, même dans les cas les plus extrêmes.

[[1]]renvoie la magnitude sans l'unité, km. Cela a été changé plus tard pour #&@@donner le même résultat.

Python 3 , score 95, 95 octets

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

Essayez-le en ligne!

Python 3 , score 133, 133 octets

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)

Essayez-le en ligne!

Powershell, 150 141 octets, score 163 153

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

Essayez-le en ligne!

Script de test:

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

Sortie:

152.731283431953 = 141 * 1.08320059171598

Explication:

• Les noms ne contiennent que des lettres, les rayons contiennent des chiffres et des points. Ainsi, nous pouvons écrire toutes les données dans une chaîne de données et effectuer une recherche regexp.
• Le script recherche toutes les sous-chaînes de gauche à droite et prend le dernier résultat trouvé.
• L'entrée doit être title-case pour réduire la chaîne de données.
• Le end of line modeest LF seulement.

Exemple:

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 octets, score 178

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

05AB1E , score 100 66 60 ( 100 61 56 octets )

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

La réponse Java du port de @ OlivierGrégoire , alors si vous aimez cette première réponse, veillez également à le faire revenir à la première place!
Entrer dans le titre.

Vérifier tous les cas de test.

05AB1E , score 100 (100 octets )

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

Entrée en minuscule. Affiche le rayon exact, aucune pénalité n’est donc ajoutée.

Vérifier tous les cas de test.

Explication:

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

Consultez cette astuce 05AB1E (sections Comment compresser de grands entiers? Et Comment compresser des chaînes ne faisant pas partie du dictionnaire? ) Pour comprendre le fonctionnement de la compression utilisée.

J'ai créé une alternative de 70 octets sur laquelle mapper sun 600,000; [Jupiter, Saturne] à 60,000; [uranus, neptune] à 30,000; [Terre, Vénus] à 6,000; [mars, ganymede, titan, mercury, callisto] à 3,000; [io, lune, europe, triton, pluto, eris] à 1,500; et [haumea; titania] to 750. Malheureusement, cela a donné un score de 117. Je verrai si je peux descendre en dessous de 100 avec une approche alternative plus tard.

Mathematica, 57 octets, score = 62 58

^{-4 octets / score grâce à lirtosiast !}

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

Effectue simplement une recherche Wolfram Alpha pour le rayon moyen.

Gelée , 28 octets, score = 31

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

Ceci utilise un hachage intégré configurable que j'ai ajouté à la suggestion de Jelly at @ lirtosiast.

L'entrée est en titlecase, la sortie est la puissance de 1.1 avec la moindre erreur.

Essayez-le en ligne!

Comment ça fonctionne

Cette réponse ne comprend que deux parties.

• Tout d'abord, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥutilise la nouvelle fonction intégrée pour mapper chacune des 20 entrées possibles sur 15 nombres entiers différents.
• Ensuite, 1.1*élève 1.1 à la puissance calculée.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘est un littéral; chaque caractère sans guillemets est remplacé par son index de base 0 dans la page de code de Jelly, ce qui donne$[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$

En divisant par deux et en couvrant cet entier jusqu'à ce que le résultat soit $0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

Ensuite, nous générons 64 nombres entiers de 64 bits en appliquant SHAKE256-4096 à la représentation sous forme de chaîne de l' ḥargument exact de la représentation interne , puis en découpant les 4096 bits résultants en 64 morceaux de 64 bits.

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

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

Pour trouver la configuration de hachage appropriée, j'ai utilisé un brute-forcer en C qui est partie du Jelly .

Python 2 , 155 octets, partition = 155

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

Essayez-le en ligne!

Étonnamment bien pour cette solution paresseuse ... examinera également l'amélioration. ;-)

Japt , 86 octets, score = 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

Essayez-le pour toutes les entrées , calculez le score ou vérifiez l'erreur la plus élevée

Très similaire à la réponse originale d'Olivier. Les entrées sont minuscules.

Après diverses améliorations des valeurs de sortie, l'erreur la plus élevée actuelle est Vénus, avec un peu plus de 4%.

Explication maintenant que les choses sont un peu plus stables:

¤¥`É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 chaîne pour les noms est sujusaurneeavemagatimecaiomoeutrplerha compressée à l'aide de la compression intégrée de Japt. Les nombres représentant les rayons sont calculés comme suit:

                          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 octets, score = 75

Premier passage à ceci; Je voulais essayer une solution de 0 pénalité pour me donner une base de travail. J'y reviendrai demain pour voir quelles améliorations peuvent être apportées, espérons-le toujours pour 0 pénalité.

La saisie est insensible à la casse.

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

L'essayer ou testez toutes les entrées

le "..." représente une chaîne contenant de nombreux non imprimables. Les points de code sont:

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

Pour donner une explication rapide: la chaîne est scindée en morceaux de 2 caractères. Nous indexons ensuite dans ce tableau en utilisant une partie de indexons la formule ovs plus un habillage d' mappons les 2 caractères à leurs points de code.

• Sauvegardé un octet / point grâce à ETH

54 octets, score = 58

Un port de solution d' Olivier .

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

Testez toutes les entrées

Ruby , 105 octets, score 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)}

Essayez-le en ligne!

Si nous divisons 700000 par les rayons, nous obtenons une séquence qui augmente raisonnablement (de manière plutôt erratique). Les incréments dans le tableau ci-dessous peuvent être approximés par les valeurs de caractères ASCII. Le problème avec cette approche est qu’elle nécessite que l’entrée soit décodée en une valeur ordonnant les différents noms par taille.

Un problème mineur est que la différence entre Eris et Haumea est assez grande. Trois caractères ~~dsont nécessaires pour coder cette incrémentation au format ASCII uniquement. La chaîne planète à index comporte deux espaces "planète fantôme" pour compléter l'index.

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 octets, score = 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)

Les sauts de ligne sont pour la lisibilité seulement.

La saisie s'effectue via la table préexistante i avec la colonne varchar v , conformément à nos normes IO .

Joint la table d'entrée à une table en mémoire sur les deux premiers caractères et renvoie les chiffres restants x100.

Traite "Titan" comme un cas particulier en utilisant IIF .

EDIT : 1 octet enregistré (et 1 point) en utilisant STUFFpour effacer les deux premiers caractères au lieu deSUBSTRING . Merci, t-clausen.dk!

EDIT 2 : Je voulais voir ce qui se passerait si j'essayais de sauvegarder un autre octet en multipliant chaque valeur de recherche par 99 au lieu de 100, et que je trouvais à ma grande surprise que le nombre d' octets avait augmenté. la précision (de l'estimation la moins précise) !.

Cela m’a amené à des tests d’essais et d’erreur, ainsi qu’à des tableaux de données fantômes d’Excel, où j’ai trouvé une solution optimale en utilisant un multiplicateur de 89 (qui a bien sûr modifié toutes mes valeurs stockées).

Donc, bien que cela ne me sauve qu'un octet, cela améliore mon score de 4,6. rapport à ma solution précédente.

EDIT 3 : A cherché plus haut au lieu de plus bas et a trouvé un facteur de multiplication encore meilleur , 198 . Les valeurs restent raisonnablement précises tout en raccourcissant de quelques caractères ma chaîne stockée, ce qui améliore mon score.

PowerShell , 203 octets, score 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]

Essayez-le en ligne!

Très similaire à la réponse d'Olivier, maintenant que je la vois, mais développée indépendamment.

Fusain , 101 octets, score = 101

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

⁺§θ⁰§θχ

Prenez le premier et le onzième caractère (de façon cyclique) de la chaîne d'entrée et concaténez-les.

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

Cherchez-les dans la chaîne SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTadivisée en paires de caractères.

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

Divisez la chaîne m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<en groupes de trois caractères et prenez le groupe correspondant.

Ｉ⍘ ... γ

Décodez le résultat sous forme de nombre base 95 en utilisant le jeu de caractères ASCII imprimable comme chiffres. Exemple: Iole 11ème caractère est I, alors nous regardons IIet trouvons que c'est le 13ème plus grand objet et sa taille correspond à celle 31qui lui correspond 19 * 95 + 17 = 1822.

Rapide 4 , 225 octets, score = 241

Probablement golfable un peu plus (peut-être dans la zone "Ga-Me-Ca"?), Mais Swift n'est pas souvent utilisé (pour une raison, peut-être.)

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

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

Essayez-le en ligne!

J'ai essayé différentes "tailles de clé" pour la carte, mais bien sûr, 1 a de nombreux affrontements et utiliser trois caractères ne me donne pas i=="Titan" ?2575:les 17 caractères, car il faut "Io" à gérer (et cela prendra plus de 3 caractères, Je pense).

JavaScript (ES6), 152 octets, score = 163

C'est une jolie solution standard, mais j'ai quand même apprécié le défi!

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

Mon score:

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

Essayez-le en ligne!

FAUX , 152 octets, score = 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!]?

Réponse paresseuse en utilisant la longueur des mots et les premières lettres, mais mon excuse est que j'utilise un langage étrange

Essayez-le en ligne! (copier coller le code, cliquer sur show puis s'exécuter)

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

Mes résultats:

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 octets, score = 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);}

Essayez-le en ligne!

Notation

Fatigué

Le nom de l'objet est transformé en un hachage à caractère unique au travers du processus fastidieux

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

dont la grosseur indique "Titan" / "Titania" comme les principaux contrevenants. L’inclusion du dernier caractère du hachage a été envisagée, mais cela nécessite tout de même unstrlen() in C. La première occurrence du caractère de hachage est recherchée dans la chaîne de hachage / données. Lorsqu'il est trouvé, le caractère suivant est pris et utilisé pour approximer le rayon de l'objet en question.

Le caractère de données contient le logarithme naturel décalé et redimensionné du rayon. Généré comme suit:

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

L'échelle a été choisie par des essais et des analyses hautement scientifiques, ainsi que par le changement visant à ramener la valeur dans la plage imprimable ASCII tout en évitant les barres obliques inverses. Un certain réarrangement des objets dans la chaîne était nécessaire en raison de certaines collisions de hachage / données.

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 octets, score = 234

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

Essayez-le en ligne!

La plupart des réponses postées semblent avoir utilisé une stratégie "coder / décoder". Je me demandais si je pouvais bien faire l'estimation du diamètre des corps célestes à l'aide d'une simple équation. C’est un exercice amusant, mais les économies d’octets modérées sont largement compensées par la pénalité de précision.

Le cœur de cette solution est l’équation d’estimation:

Radius = 39**4/x**2.18

où x est deux fois le rang du rayon du corps.

Je génère la valeur de x en fonction de la chaîne d'entrée à l'aide d'une modification de la solution Python 2 de @Erik the Outgolfer. J'ai économisé quelques octets sur son code en reformulant mes équations pour qu'elles fonctionnent avec [2..40] au lieu de [1..20].

Le code permettant de générer des ordres de classement occupe plus de 2/3 des octets de la solution. Si quelqu'un dispose d'un moyen plus compact de générer des rangs, cette solution pourrait être encore raccourcie. En raison de la pénalité de précision (autour de 2,6), le score pourrait s’améliorer un peu.

Générer l'équation

J'ai utilisé des méthodes statistiques pour rechercher des équations simples permettant d'estimer la taille de chaque corps en fonction de son rang. Dans le cadre du suivi de la solution Ruby de @Level River St et de la généralisation, je me suis basé sur des équations de la forme:

Radius = A/(Rank)**B

En travaillant dans R, j’ai utilisé des modèles linéaires sur le log des rayons pour développer des estimations initiales, puis une optimisation non linéaire, en semant l’optimisation avec les résultats des modèles linéaires, pour rechercher des solutions minimisant la fonction de pénalité spécifiée dans problème.

La valeur estimée de A dans l'équation ci-dessus est de sept chiffres. J'ai donc recherché une expression simple pour économiser quelques octets. J'ai cherché des expressions de la forme

x**y

pour deux chiffres x et un chiffre y (pour un total de cinq octets, économiser deux octets, soit environ cinq points, compte tenu de la pénalité) qui ne diffère pas trop de la valeur optimale de A et qui ne gonfle pas trop la pénalité et se termine avec le (sinon inexplicable):

39**4

TI-BASIC (TI-84), 285 octets, score = 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 simple programme "index dans la chaîne à la liste". Peut être joué au golf plus loin.

L'entrée est en Anset est l'un des noms des objets en majuscules.
La sortie est Ansentrée et est automatiquement imprimée.

Exemple:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Explication:
(La liste et le nom de la chaîne de radiations ont été raccourcis par souci de concision. ...Est utilisé pour indiquer le reste de la liste / chaîne.)

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

Modèle visuel:

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