«En parcourant l'univers…»

48

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 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 .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 Rn le rayon attendu de l'objet , et la réponse de votre programme pour cet objet.nthAn

Ensuite, votre score est défini comme:

S=L×max1i20(max(AiRi,RiAi)2)

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:10010001737

S=100×(17371000)2=302

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.
Arnauld
la source
2
Sandbox (maintenant supprimé). Merci à tous ceux qui ont fait part de leurs commentaires, et particulièrement à xnor pour avoir aidé à corriger la formule de notation
Arnauld
1
Je vois que la notation a été changée à la puissance de 2 pour le diff? Dans ce cas, ma réponse exacte de 100 octets est plus courte que mon approximation de 70 octets (qui avait déjà marqué 91 auparavant, mais maintenant 117 ..)
Kevin Cruijssen
1
@KevinCruijssen L'idée sous-jacente était d'empêcher que des réponses extrêmement courtes (renvoyant 1 ou 2 constantes) ne soient pénalisées par un facteur raisonnable et puissent éventuellement l'emporter sur des plus sophistiquées.
Arnauld
2
J'approuve la place dans la fonction de notation. Mon meilleur résultat précédent était un score de 60 avec 2 octets à obtenir 7512pour tous les cas de test. Je verrai si je vais bientôt créer une solution MathGolf, mais il sera difficile de battre 05AB1E.
maxb
2
@maxb Vous devrez battre le score de Jelly de 37, et non celui de 05AB1E de 60; p
Kevin Cruijssen

Réponses:

28

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.

AdmBorkBork
la source
3
C'est tout ce que vous devez savoir sur KPI :)
mazzy
12
Pourquoi est-ce que ça donne autant de voix?!
Shaggy
11
@Shaggy Je suis aussi confus à ce sujet ..: S C'est de loin la réponse la plus paresseuse et la plus performante (ne le prenez pas comme AdmBorkBork , mais je pense que les réponses Jelly et Java méritent beaucoup plus que les votes positifs). Les gens ne voient probablement que la partie de 3 octets (ou pensent qu'un score élevé est meilleur que inférieur) et ignore tout le reste. xD Dans la description originale du défi d'Arnauld dans le bac à sable, cette réponse n'aurait même pas été possible, car elle autorisait un pourcentage d'erreur maximal de 95% pour chaque entrée / sortie. Et bien. Profitez du représentant gratuit AdmBorkBork . ;)
Kevin Cruijssen
6
Cela correspond aux critères de la question. Je pense que les gens votent parce que c'est tellement évident que beaucoup n'y auraient pas pensé. Cela dénote également un défi avec un système de notation imparfait, si on peut en abuser de cette façon.
Elcan
9
Les gens votent sur PPCG pour toutes sortes de raisons, pas seulement à cause du score brut (voir mon énorme réponse Redstone de Minecraft, par exemple ). J'ai voté en faveur de cette réponse parce que c'est un exemple clair et simple de l'extrémité du spectre de la stratégie (le spectre entre "renvoyer les valeurs exactes" et "enregistrer des octets pour renvoyer une approximation et prendre la pénalité").
BradC
25

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
Dennis
la source
20

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 .
Olivier Grégoire
la source
Merci @KevinCruijssen! C'est un bon golf, utilisant des caractères Unicode dans une chaîne au lieu d'un tableau de valeurs décimales. :-)
Olivier Grégoire
Heureux d'avoir pu aider et bonne réponse! :) PS: En ce qui concerne la raison pour laquelle j’ai ajouté (...-7): Le caractère non imprimable (char)0est vide et j’ai donc dû ajouter quelque chose. J'ai d'abord essayé 9et je n'avais qu'un 8chiffre, mais j'ai 9bien sûr donné des onglets nécessitant plusieurs \t(2 octets chacun), ainsi 8qu'une erreur sur un caractère non échappé utilisé.
Kevin Cruijssen
@KevinCruijssen Pour être honnête, j'ai essayé pendant quelques heures hier d'obtenir de meilleures valeurs en développant votre multiplication *100-700et en jouant avec les valeurs-as-string et ces deux nombres, mais ceux-ci sont les meilleurs, en fait, certaines valeurs peuvent diminuer l'octet compter, mais alors le score reste le même. Ainsi, le repérage aléatoire a été (l'un des) le meilleur des cas;)
Olivier Grégoire
Parlez d'indisplayable! Cette entrée excite vraiment mon Firefox au point que je ne peux pas vraiment lire le reste de la page correctement :-(
Neil
9

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.

DavidC
la source
1
Un autre wolfram intégré. C'est comme si on détectait des pertes de poids
OganM
J'aurais répondu à cela, mais je ne connais pas le langage wolfram lol
Quintec
En fait, cela nécessite également une connexion Internet (testé sur 10.2)
user202729
@ user202729, Vos deux dernières suggestions, utiles, sont maintenant intégrées. L'utilisation d'entités sélectionnées, telles que des corps astronomiques, nécessite en effet une connexion Internet.
DavidC
1
Ugh, ce sont les unités par défaut pour le rayon sont des miles? Au moins, il a des unités saines (métriques) par défaut pour la masse ...
Neil
7

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!

ovs
la source
6

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]
mazzy
la source
4

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.

Kevin Cruijssen
la source
1
J'ai trouvé un meilleur hash utilisant une chaîne de 25 caractères au lieu de 30. Cochez ma réponse Java si vous souhaitez mettre à jour cette réponse;)
Olivier Grégoire
@ OlivierGrégoire Merci pour le heads-up. -6 score et -7 octets. :)
Kevin Cruijssen
4

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.

LegionMammal978
la source
1
Hmm. Cela ne compte-t-il pas comme utilisant Internet? Sauf si Mathematica contient le moteur WolframAlpha complet
ASCII uniquement
@ ASCII uniquement, je veux dire, les jeux de données de Mathematica sont autorisés et la WolframAlphafonction a été utilisée au moins quatre fois ...
LegionMammal978
Hmm. Cela ressemble un peu à une décision arbitraire. Qu'est-ce qui empêche d'autres langues d'ajouter des fonctions de moteur de recherche? Les jeux de données de l'OMI sont un peu différents - le téléchargement de tous est tellement énorme qu'un serveur central vous le donne en cas de besoin
ASCII uniquement
@ ASCII uniquement Si vous êtes inquiet, vous pouvez toujours poser une question sur Meta.
LegionMammal978
@leg Dans ce cas, les données peuvent être utilisées hors connexion après le téléchargement. Dans ce cas, ce n'est pas.
user202729
4

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]1376510639244

En divisant par deux et en couvrant cet entier jusqu'à ce que le résultat soit 0[376510639244,188255319622,94127659811,47063829905,,5,2,1,0][188255319622,94127659811,47063829906,,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.

264[0,264)

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 .

Dennis
la source
3

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. ;-)

Erik le golfeur
la source
3

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
Kamil Drakari
la source
3

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

Hirsute
la source
Je pense que vous pouvez sauvegarder un octet en déplaçant la première entrée (n ° 23) jusqu'à la fin, et en supprimant le %24:-)
ETHproductions
@ETHproductions, ça ne semble pas fonctionner
Shaggy
Voici ce que je pensais
ETHproductions
@ETHproductions: Ah, oui, je me suis dit que je devrais ajouter un élément de marque de réservation au début du tableau. Merci.
Shaggy
3

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
Level River St
la source
3

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.

BradC
la source
1
Vous pouvez économiser 1 octet en utilisant STUFF (valeur, 1,2, '') au lieu de sous
t-clausen.dk
2

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.

AdmBorkBork
la source
1

Fusain , 101 octets, score = 101

I⍘§⪪“_″FJ⁼⦄b\l≕)T‹#⊙xO-nη⁻À↓ζ↥ς§%H8H“ρj✳Hρl× S↶…|UD⎇LkfZ”³⌕⪪”@/rjmq_↙§E▶νF↨oº⁷÷K⁻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_↙§E▶νF↨oº⁷÷K⁻eDH:_Tbk¦�”²

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

§⪪“_″FJ⁼⦄b\l≕)T‹#⊙xO-nη⁻À↓ζ↥ς§%H8H“ρj✳Hρl× S↶…|UD⎇LkfZ”³

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.

I⍘ ... γ

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.

Neil
la source
1

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

Simone Chelo
la source
1

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!

zruF
la source
1

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
Terjerber
la source
1634
Je l'ai mis à jour pour utiliser la moitié de 1822 (911) à la place. Je pourrais faire un cas spécial pour Haumea, donc ce conseil ne fonctionne plus. J'ai essayé d'utiliser 817 (la moitié de 1634) mais ce n'était pas bon. Si vous voulez travailler votre magie et trouver le nouveau numéro le plus optimal, n'hésitez pas.
Terjerber
1

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
gastropner
la source
0

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
CCB60
la source
L'algorithme de scoring semble vraiment faire mal à cette méthode - je suppose qu'il ferait mieux sous la norme d'erreur L2 ou L1. Bien que vous perdiez des octets en stockant les noms de toute façon.
lirtosiast
@lirtosiast Acceptez les deux points. Fait intéressant, un ajustement des moindres carrés (norme L2) est également très bon avec cet algorithme de notation. Il n’ya que 5% de peine en plus que la meilleure équation que j’ai trouvée. Enregistrement des noms: je ne pouvais pas trouver un moyen plus compact de générer une séquence ascendante de nombres à partir de la saisie de texte. Les approches modulo arithmétiques prises dans d'autres réponses randomisent l'ordre.
CCB60
0

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
Tau
la source