Sie erhalten den Namen eines der 20 größten Objekte im Sonnensystem. Ihre Aufgabe ist es, eine Annäherung des Radius in Kilometern zurückzugeben.

Dies ist eine Code-Herausforderung, bei der Ihre Punktzahl aus der Länge Ihres Codes (in Bytes) multipliziert mit einem Strafmaß , basierend auf Ihrer schlechtesten Annäherung, besteht. Daher gewinnt die niedrigste Punktzahl .$\ge 1$

_{"As we travel the universe" ist die letzte Zeile des Songs Planet Caravan von Black Sabbath , der später auch von Pantera gedeckt wurde .}

Das Sonnensystem Objekte

Quelle: Wikipedia

NB: Der Rang wird nur zu Informationszwecken angegeben. Die Eingabe ist der Name des Objekts.

  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

Oder als Copy-Paste-Friendly-Listen:

'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

Ihr Ergebnis

Sei der erwartete Radius des -Objekts und sei die Antwort Ihres Programms für dieses Objekt.$R_n$$n^{th}$$A_n$

Dann ist Ihre Punktzahl definiert als:

Wobei die Länge Ihres Codes in Bytes ist.$L$

Beispiel:

Wenn die Größe Ihres Codes Bytes beträgt und Ihre schlechteste Annäherung auf dem Mond mit einem geschätzten Radius von km anstelle von km erfolgt, lautet Ihre Punktzahl:$100$$1000$$1737$

Je niedriger, desto besser.

Empfohlener Header für Ihre Antwort:

Language, 100 bytes, score = 302

Mit diesem Skript können Sie Ihre Punktzahl berechnen (erste Zeile = Codelänge, nächste 20 Zeilen = Ihre Ausgaben, von Sun bis Titania).

Regeln

• Sie können den Namen des Objekts entweder in Kleinbuchstaben, in Großbuchstaben oder genau wie oben beschrieben (Titelbuchstaben) eingeben. Andere Mischfälle sind nicht zulässig.
• Die Eingabe ist garantiert einer der 20 möglichen Namen.
• Sie können entweder Ganzzahlen oder Gleitkommazahlen zurückgeben. In beiden Fällen muss die Strafe direkt mit diesen Werten berechnet werden (nicht gerundete Werte bei Floats).
• Sie müssen positive Werte zurückgeben.
• Leere Programme sind nicht erlaubt.

PowerShell , 3 Bytes, Punktzahl 3637

2e4

Probieren Sie es online!

Sehr naiv, langweilig, Umsetzung; Gibt einfach zurück, 20000unabhängig von der Eingabe. Experimente mit Dingen wie der speziellen Verschalung der Sonne oder der Verwendung von Gleitkommawerten 2führten zu schlechteren Ergebnissen, da die Codelänge so lang wurde, dass etwaige Zuwächse im Größenvergleich ausgeglichen wurden.

Jelly , 34 Bytes, Score = 37

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

Die Eingabe erfolgt in Großbuchstaben, die Ausgabe ist die Potenz von 1,1 mit dem geringsten Fehler.

Probieren Sie es online!

Wie es funktioniert

OḌ“⁸|5/!‘%ƒị“RNFLOJMjs⁽\u[USJ‘1.1*  Main link. Argument: s (string)

O                                   Ordinal; map the char in s to their code points.
                                        "ERIS" -> [69,82,73,83]
 Ḍ                                  Undecimal; treat the result as an array of digits
                                    in base 10 and convert it to integer.
                                        [69,82,73,83] -> 69000+8200+730+83 = 78013
  “⁸|5/!‘                           Literal; yield [136, 124, 53, 47, 33].
         %ƒ                         Fold the array by modulus, using the computed
                                    integer as initial value.
                                        78013 -> 78013%136%124%53%47%33 = 32
            “RNFLOJMjs⁽\u[USJ‘      Literal; yield [82, 78, 70, 76, 79, 74, 77, ...
                                    106, 115, 141, 92, 117, 91, 85, 83, 74].
           ị                        Retrieve the element from the array to the right,
                                    at the index to the left.
                                    Indexing is 1-based and modular.
                                        32 = 16 (mod 16) -> 'J' = 74
                              1.1*  Raise 1.1 to the computed power.
                                        74 = 1.1**74 = 1156.268519450066

Java (JDK) , 90 Bytes, Score = 97

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

Probieren Sie es online!

• Dieser Eintrag verwendet sowohl nicht anzeigbare als auch Mehrbyte-Unicode-Zeichen (Java akzeptiert sie jedoch trotzdem). Überprüfen Sie den TIO auf den genauen Code.
• Die Eingabe muss in Groß- / Kleinschreibung erfolgen.
• Dieser Code rundet die Werte auf das beste Vielfache von 100 (manchmal aufwärts, manchmal abwärts), sodass die letzten beiden Ziffern bei der Codierung übersprungen und der Wert dann durch Multiplikation mit 100 approximiert werden kann.
• In diesem Eintrag werden verschiedene Hashes verwendet, um eine Zeichenfolge mit 25 Codepunkten anzupassen (kürzeste Zeichenfolge, die ich finden konnte).

Credits

• -48 Punkte (-45 Bytes) dank Kevin Cruijssen durch direktes Codieren der Radien (geteilt durch 100), Stringanstatt sie in einem expliziten intArray fest zu codieren .

Wolfram-Sprache 114 103 97 88 86 82 Bytes. Ergebnis = 114 103 97 89 87 83 Punkte

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

Mindestens 6 Punkte gespart dank Dennis, mehrere dank lirtosiastund 6 dank user202729.

Obwohl Mathematica Sonnensystemdaten (sowie viele zusätzliche astronomische Daten) abrufen kann, sind einige geringfügige Änderungen erforderlich, wie unten erläutert.

Interpreter[#,"AstronomicalObject"]&Gibt die Entität (dh das rechnergesteuerte Objekt) zurück, die dem durch dargestellten Begriff zugeordnet ist #.

EntityValue[AstronomicalObject[],"Radius"]Gibt den Radius des Objekts in Meilen zurück. Im Fall von "Haumea" wird der Wert 816,27 (dh 507 * 1,61) zurückgegeben.

Multiplikation des Radius durch 1.61Umrechnung von Meilen in km. Dezimalwerte und nicht ganze Zahlen sind selbst im extremsten Fall für einen Fehler von weniger als 1% verantwortlich.

[[1]]Gibt die Größe ohne die Einheit zurück, km. Dies wurde später geändert #&@@und ergab das gleiche Ergebnis.

Python 3 , Punktzahl 95, 95 Bytes

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

Probieren Sie es online!

Python 3 , Punktzahl 133, 133 Bytes

lambda n:int(f'00e0{10**18+10**6}10x1h2411j4?00??811i1207wazxmwuvko?mw??xc1ze1ldyujz6zysi4?ob??k9lym6w'[int(n,35)%87%52%24-1::23],36)

Probieren Sie es online!

Powershell, 150 141 Bytes, 163 153 Punkte

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

Probieren Sie es online!

Testskript:

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

Ausgabe:

152.731283431953 = 141 * 1.08320059171598

Erläuterung:

• Namen enthalten nur Buchstaben, Radien enthalten Ziffern und Punkte. So können wir alle Daten in einen Datenstring schreiben und eine reguläre Suche durchführen.
• Das Skript sucht von links nach rechts nach allen Teilzeichenfolgen und nimmt das zuletzt gefundene Ergebnis.
• Die Eingabe muss in Groß- und Kleinschreibung erfolgen, um die Datenzeichenfolge zu reduzieren.
• Das end of line modeist nur LF.

Beispiel:

Titania         Triton         Titan
--------------  -------------  -------------
T       -> 1.3  T      -> 1.3  T      -> 1.3
Ti      -> 2.5  Tr     ->      Ti     -> 2.5
Tit     ->      Tri    ->      Tit    ->
Tita    ->      Trit   ->      Tita   ->
Titan   ->      Triton ->      Titan  ->
Titani  -> .8
Titania ->

Result is .8    Result is 1.3  Result is 2.5

Powershell, 178 Bytes, 178 Punkte

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

05AB1E , Ergebnis 100 66 60 ( 100 61 56 Bytes )

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

Port von @ OlivierGrégoires Java-Antwort . Wenn Ihnen diese erste Antwort gefällt, sollten Sie ihn ebenfalls bewerten!
Eingabe in Titelzeile.

Überprüfen Sie alle Testfälle.

05AB1E , 100 Punkte (100 Bytes )

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

Eingabe in Kleinbuchstaben. Gibt den genauen Radius aus, sodass keine Strafe hinzugefügt wird.

Überprüfen Sie alle Testfälle.

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E an (Abschnitte So komprimieren Sie große Ganzzahlen? Und So komprimieren Sie Zeichenfolgen, die nicht Teil des Wörterbuchs sind? ) , Um zu verstehen, wie die verwendete Komprimierung funktioniert.

Ich habe eine 70-Byte-Alternative erstellt, auf die die Sonne 600,000abgebildet wird. [Jupiter, Saturn] zu 60,000; [Uranus, Neptun] zu 30,000; [Erde, Venus] zu 6,000; [Mars, Ganymed, Titan, Quecksilber, Callisto] zu 3,000; [io, Mond, Europa, Triton, Pluto, Eris] zu 1,500; und [haumea; titania] zu 750. Leider hat das eine Punktzahl von 117. Ich werde später sehen, ob ich mit einem alternativen Ansatz unter 100 kommen kann.

Mathematica, 57 Bytes, Score = 62 58

^{-4 Bytes / Score dank Lirtosiast !}

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

Führt einfach eine Wolfram Alpha-Suche für den mittleren Radius durch.

Jelly , 28 Bytes, Score = 31

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

Hierfür wird ein konfigurierbares Hashing verwendet, das ich auf Vorschlag von @ lirtosiast zu Jelly hinzugefügt habe.

Die Eingabe erfolgt in der Titelzeile, die Ausgabe ist die Potenz von 1,1 mit dem geringsten Fehler.

Probieren Sie es online!

Wie es funktioniert

Diese Antwort besteht nur aus zwei Teilen.

• Erstens “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥverwendet das neue integrierte in jedem der 20 möglichen Eingaben zu 15 verschiedene ganze Zahlen abzubilden.
• Dann 1.1*hebt 1.1 auf die berechnete Leistung.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ist ein wörtliches; Jedes nicht in Anführungszeichen gesetzte Zeichen wird in Jellys Codepage durch einen 0-basierten Index ersetzt. Dies ergibt .$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$

Das integrierte Hashing ḥordnet zunächst einer Ganzzahl zu, indem es jede Zahl inkrementiert, das Ergebnis dann als Ganzzahl auf der Basis der bijektiven 250-stelligen Zahl behandelt und addiert . Dies ergibt .$[95, 95, 169, 55, 242]$$1$$376510639244$

Indem Sie diese Ganzzahl halbieren und auf , erhalten Sie die Sequenz mit den Vorwärtsdifferenzen .$0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

Als Nächstes generieren wir 64 64-Bit-Ganzzahlen, indem wir SHAKE256-4096 auf die Zeichenfolgendarstellung der internen Darstellung des ḥrechten Arguments anwenden und dann die resultierenden 4096 Bits in 64 64-Bit- Blöcke zerlegen .

ḥBerechnet nun das Skalarprodukt der 39 Differenzen und der ersten 39 generierten 64-Bit-Ganzzahlen, Modulo . Dies ergibt eine ganze Zahl in .$2^{64}$$[0, 2^{64})$

Die Liste hat die Länge 15, also multiplizieren wir die generierte Ganzzahl mit 15 und nehmen die 64 höher Bits des Ergebnisses. Dies ergibt eine ganze Zahl in , mit der wir die Liste indizieren.$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$$[0, 15)$

Um die passende Hash-Konfiguration zu finden, habe ich in C einen Brute-Forcer verwendet, der Teil des Jelly Repo ist .

Python 2 , 155 Bytes, Score = 155

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

Probieren Sie es online!

Überraschend gut für diese faule Lösung ... wird sich auch um die Verbesserung kümmern. ;-)

Japt , 86 Bytes, 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

Probieren Sie es für alle Eingaben aus , berechnen Sie die Punktzahl oder überprüfen Sie den höchsten Fehler

Sehr ähnlich zu Oliviers ursprünglicher Antwort. Die Eingabe erfolgt in Kleinbuchstaben.

Nach verschiedenen Verbesserungen der Ausgangswerte liegt der derzeit höchste Fehler bei Venus mit etwas mehr als 4%.

Erklärung jetzt, da die Dinge ein bisschen stabiler sind:

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

Die Zeichenfolge für die Namen wird sujusaurneeavemagatimecaiomoeutrplerhamithilfe der in Japt integrierten Komprimierung komprimiert. Die Zahlen, die die Radien darstellen, werden wie folgt berechnet:

                          My value | Actual value
                          ---------+-------------
7 * 10 ^ 3 = 7000 * 100 =   700000 | 696342
7 * 100    = 700  * 100 =    70000 |  69911
6 * 100    = 600  * 100 =    60000 |  58232
16 * 16    = 256  * 100 =    25600 |  25362
16 * 16    = 256  * 100 =    25600 |  24622
64         = 64   * 100 =     6400 |   6371
64 - 1     = 63   * 100 =     6300 |   6052
32 + 1     = 33   * 100 =     3300 |   3390
13 * 2     = 26   * 100 =     2600 |   2634
13 * 2     = 26   * 100 =     2600 |   2575
12 * 2     = 24   * 100 =     2400 |   2440
12 * 2     = 24   * 100 =     2400 |   2410
16 + 1 + 1 = 18   * 100 =     1800 |   1822
16 + 1     = 17   * 100 =     1700 |   1737
16         = 16   * 100 =     1600 |   1561
14         = 14   * 100 =     1400 |   1353
12         = 12   * 100 =     1200 |   1186
12         = 12   * 100 =     1200 |   1163
8          = 8    * 100 =      800 |    816
788                     =      788 |    788

Japt, 77 76 75 Bytes, Score = 75

Erstmal vorbei; Ich wollte eine 0-Straflösung ausprobieren, um mir eine Ausgangsbasis für die Abarbeitung zu geben. Werde morgen darauf zurückkommen, um zu sehen, welche Verbesserungen vorgenommen werden können, hoffentlich noch für 0 Strafpunkte.

Bei der Eingabe wird die Groß- und Kleinschreibung nicht berücksichtigt.

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

Probieren Sie es aus oder testen Sie alle Eingaben

Das "..."stellt eine Zeichenfolge dar, die viele nicht druckbare Elemente enthält. Die Codepunkte sind:

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

Eine kurze Erklärung: Die Zeichenfolge wird in Stücke von 2 Zeichen aufgeteilt. Anschließend indizieren wir dieses Array mit einem Teil der ovs-Formel plus Indexumbruch und ordnen die beiden Zeichen ihren Codepunkten zu.

• Dank ETH ein Byte / Punkt gespart

54 Bytes, Score = 58

Ein Port von Oliviers Lösung .

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

Testen Sie alle Eingänge

Ruby , 105 Bytes, Ergebnis 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)}

Probieren Sie es online!

Wenn wir 700000 durch die Radien dividieren, erhalten wir eine Sequenz, die einigermaßen linear (wenn auch ziemlich unregelmäßig) ansteigt. Die Inkremente in der folgenden Tabelle können durch die ASCII-Werte von Zeichen angenähert werden. Das Problem bei diesem Ansatz ist, dass die Eingabe auf einen Wert dekodiert werden muss, der die verschiedenen Namen nach Größe sortiert.

Ein kleines Problem ist, dass der Unterschied zwischen Eris und Haumea ziemlich groß ist. Drei Zeichen ~~dsind erforderlich, um dieses Inkrement nur im ASCII-Format zu codieren. Die Planet-zu-Index-Zeichenfolge enthält zwei "Geisterplaneten" -Lücken, um den Index aufzufüllen.

700000/r    increment from previous
0.994774    
9.960407    8.965633
11.95806    1.997657
27.45612    15.49805
28.28129    0.825178
109.2987    81.0174
115.0598    5.761118
205.4106    90.3508
264.3667    58.95612
270.4241    6.057335
285.3861    14.96199
288.9386    3.552524
382.1855    93.24692
400.8877    18.70223
446.0871    45.19939
514.6652    68.57806
587.1349    72.46972
598.7463    11.61144
853.3603    254.6139
883.6827    30.32245

T-SQL, 203 202 201 196 Bytes, 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)

Zeilenumbrüche dienen nur der Lesbarkeit.

Die Eingabe erfolgt über bereits vorhandene Tabelle entnommen i mit Varchar - Spalte v , je unseren IO - Standards .

Verbindet die Eingabetabelle mit einer In-Memory-Tabelle für die ersten beiden Zeichen und gibt die verbleibenden Stellen x100 zurück.

Behandelt "Titan" als Sonderfall mit IIF.

BEARBEITEN : 1 Byte (und 1 Punkt) wurde gespeichert, indem STUFFdie ersten beiden Zeichen anstelle von gelöscht wurden SUBSTRING. Danke, t-clausen.dk!

EDIT 2 : Ich wollte sehen, was passieren würde, wenn ich versuchen würde, ein weiteres Byte zu speichern, indem ich jeden Suchwert mit 99 anstatt mit 100 multipliziere, und stellte zu meiner Überraschung fest, dass dies tatsächlich die Genauigkeit (der ungenauesten Schätzung) erhöht !

Dies führte mich zu einigen Testversuchen und einigen ausgefallenen Excel-Was-wäre-wenn-Datentabellen, in denen ich mit einem Multiplikator von 89 (der natürlich alle meine gespeicherten Werte änderte) eine optimale Lösung fand .

Das spart mir zwar nur ein Byte, verbessert aber meine Punktzahl gegenüber meiner vorherigen Lösung um 4,6 .

EDIT 3 : Suche höher statt niedriger und finde einen noch besseren Multiplikationsfaktor, 198 . Die Werte bleiben ziemlich genau, während die gespeicherte Zeichenfolge um einige Zeichen gekürzt wird, was meine Punktzahl verbessert.

PowerShell , 203 Byte, Punktzahl 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]

Probieren Sie es online!

Sehr ähnlich zu Oliviers Antwort, jetzt, da ich es sehe, aber unabhängig entwickelt.

Kohle , 101 Bytes, Score = 101

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

⁺§θ⁰§θχ

Nehmen Sie das 1. und 11. Zeichen (zyklisch) der Eingabezeichenfolge und verketten Sie sie.

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

Schlagen Sie sie in der Zeichenfolge nach, SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTadie in Zeichenpaare aufgeteilt ist.

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

Teilen Sie die Zeichenfolge m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<in Gruppen von drei Zeichen und nehmen Sie die entsprechende Gruppe.

Ｉ⍘ ... γ

Dekodieren Sie das Ergebnis als Basis-95-Zahl unter Verwendung des druckbaren ASCII-Zeichensatzes als Ziffern. Beispiel: IoDas 11. Zeichen von ist I, also schauen wir nach IIund finden, dass es das 13. größte Objekt ist und seine Größe 31der Abbildung entspricht 19 * 95 + 17 = 1822.

Swift 4 , 225 Bytes, Score = 241

Wahrscheinlich ein paar mehr Golf (vielleicht im "Ga-Me-Ca" -Bereich?), Aber Swift wird nicht oft verwendet (vielleicht aus einem Grund.)

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

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

Probieren Sie es online!

Ich habe verschiedene "Schlüsselgrößen" für die Karte ausprobiert, aber natürlich hat 1 viele Konflikte und die Verwendung von drei Zeichen ergibt keine i=="Titan" ?2575:17 Zeichen für mich , da es "Io" zum Verwalten gibt (und mehr als 3 Zeichen benötigt werden, Ich denke).

JavaScript (ES6), 152 Byte, Score = 163

Nun, es ist eine hübsche Standardlösung, aber ich habe die Herausforderung trotzdem genossen!

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

Meine Punktzahl:

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

Probieren Sie es online!

FALSE , 152 Bytes, 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!]?

Faule Antwort mit Wortlängen und Anfangsbuchstaben, aber meine Entschuldigung ist, dass ich eine seltsame Sprache verwende

Probieren Sie es online! (Kopieren, Code einfügen, Show drücken und dann ausführen)

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

Meine Ergebnisse:

Sun       : 696004.00 penalty ratio = (696342.00 / 696004.00 )² = 1.00097
Jupiter   : 47372.00  penalty ratio = (69911.00  / 47372.00  )² = 2.17795
Saturn    : 41906.00  penalty ratio = (58232.00  / 41906.00  )² = 1.93095
Uranus    : 41906.00  penalty ratio = (41906.00  / 25362.00  )² = 2.73014
Neptune   : 47372.00  penalty ratio = (47372.00  / 24622.00  )² = 3.70166
Earth     : 5466.00   penalty ratio = (6371.00   / 5466.00   )² = 1.35855
Venus     : 5466.00   penalty ratio = (6052.00   / 5466.00   )² = 1.22591
Mars      : 1822.00   penalty ratio = (3390.00   / 1822.00   )² = 3.46181
Ganymede  : 1822.00   penalty ratio = (2634.00   / 1822.00   )² = 2.08994
Titan     : 1822.00   penalty ratio = (2575.00   / 1822.00   )² = 1.99737
Mercury   : 1822.00   penalty ratio = (2440.00   / 1822.00   )² = 1.79342
Callisto  : 1822.00   penalty ratio = (2410.00   / 1822.00   )² = 1.74959
Io        : 1822.00   penalty ratio = (1822.00   / 1822.00   )² = 1.00000
Moon      : 1822.00   penalty ratio = (1822.00   / 1737.00   )² = 1.10026
Europa    : 1822.00   penalty ratio = (1822.00   / 1561.00   )² = 1.36236
Triton    : 1822.00   penalty ratio = (1822.00   / 1353.00   )² = 1.81343
Pluto     : 1822.00   penalty ratio = (1822.00   / 1186.00   )² = 2.36008
Eris      : 1822.00   penalty ratio = (1822.00   / 1163.00   )² = 2.45435
Haumea    : 911.00    penalty ratio = (911.00    / 816.00    )² = 1.24640
Titania   : 911.00    penalty ratio = (911.00    / 788.00    )² = 1.33655

Max. penalty ratio = 3.70166 for Neptune
Score = ceil(152 x 3.70166) = 563

C (gcc) , 118 Bytes, 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);}

Probieren Sie es online!

Wertung

Heruntergewirtschaftet

Der Objektname wird durch den umständlichen Vorgang in einen einstelligen Hash umgewandelt

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

deren Aufblähung auf "Titan" / "Titania" als Haupttäter hindeutet. Das Einbeziehen des letzten Zeichens in den Hash wurde berücksichtigt, dies erfordert jedoch weiterhin ein strlen()in C. Das erste Vorkommen des Hashzeichens wird in der Hash- / Datenzeichenfolge gesucht. Wenn es gefunden wird, wird das nächste Zeichen verwendet, um den Radius des betreffenden Objekts zu approximieren.

Das Datenzeichen enthält den verschobenen, skalierten natürlichen Logarithmus des Radius. So generiert:

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

Die Skala wurde durch hochgradig wissenschaftliches Ausprobieren und Verschieben des Werts innerhalb des druckbaren ASCII-Bereichs unter Vermeidung von Backslashes ausgewählt. Einige Neuanordnungen der Objekte in der Zeichenfolge waren aufgrund einiger Hash- / Datenkollisionen erforderlich.

i;                                      Return value
f(char*s){                              s is object name
    i=                                  Implicit return
    exp(                                Raise e to some power
        (
            strchr(                     Find hash
                "...",                  Hash/data string
                (*s^s[1]*4)+            Calculate...
                (strlen(s)!=5)&127|32   ...hash
            )
            [1]                         Char following hash holds the power
            +55                         Shift it
        )/13.5                          Scale it
    );                                  Use it
}                                       Exit

Python 2 , 89 Bytes, Score = 234

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

Probieren Sie es online!

Die meisten Antworten scheinen eine "Kodierungs- / Dekodierungs" -Strategie verwendet zu haben. Ich fragte mich, wie gut ich den Durchmesser von Himmelskörpern mit einer einfachen Gleichung abschätzen könnte. Es war eine unterhaltsame Übung, aber die moderaten Byteeinsparungen werden durch die Genauigkeitsstrafe mehr als wettgemacht.

Der Kern dieser Lösung ist die Schätzgleichung:

Radius = 39**4/x**2.18

Dabei ist x die doppelte Rangordnung des Radius des Körpers.

Ich generiere den Wert von x basierend auf der Eingabezeichenfolge mit einer Modifikation der Python 2-Lösung von @Erik the Outgolfer. Ich habe ein paar Bytes in seinem Code gespart, indem ich meine Gleichungen neu formuliert habe, um mit [2..40] anstatt mit [1..20] zu arbeiten.

Der Code zum Erzeugen von Rangfolgen belegt mehr als 2/3 der Bytes der gesamten Lösung. Wenn jemand eine kompaktere Art der Ranggenerierung hat, könnte diese Lösung weiter verkürzt werden. Aufgrund des Genauigkeitsnachteils (ca. 2,6) würde sich die Punktzahl erheblich verbessern.

Die Gleichung erzeugen

Ich habe statistische Methoden verwendet, um nach einfachen Gleichungen zu suchen, um die Größe jedes Körpers basierend auf seinem Rang zu schätzen. Zum Teil verfolgte ich die Erkenntnisse in der Ruby-Lösung von @Level River St. und verallgemeinerte sie.

Radius = A/(Rank)**B

In R verwendete ich lineare Modelle für das Protokoll der Radien, um anfängliche Schätzungen zu erstellen, und verwendete dann die nichtlineare Optimierung, wobei die Optimierung mit den Ergebnissen der linearen Modelle verknüpft wurde, um nach Lösungen zu suchen, die die in der angegebenen Straffunktion minimierten Problem.

Der geschätzte Wert von A in der obigen Gleichung ist siebenstellig, daher habe ich nach einem einfachen Ausdruck gesucht, um ein paar Bytes zu sparen. Ich habe nach Ausdrücken der Form gesucht

x**y

für zweistellige x- und 1-stellige y-Werte (für insgesamt fünf Bytes, wobei zwei Bytes oder etwa fünf Punkte unter Berücksichtigung der Strafe gespart wurden), die sich nicht zu stark vom optimalen Wert von A unterschieden und die Strafe nicht sehr aufblähten, und endeten up with the (sonst unerklärlich):

39**4

TI-BASIC (TI-84), 285 Bytes, 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

Ein einfaches Programm "Index in String to List". Kann weiter golfen werden.

Die Eingabe erfolgt in AnsGroßbuchstaben und ist einer der Namen der Objekte.
Die Ausgabe erfolgt in Ansund wird automatisch ausgedruckt.

Beispiel:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Erläuterung:
(Radienliste und Namenszeichenfolge wurden der Kürze halber gekürzt. Wird ...verwendet, um den Rest der Liste / Zeichenfolge anzugeben.)

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

Visuelles Modell:

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