Otrzymasz nazwę jednego z 20 największych obiektów w Układzie Słonecznym. Twoim zadaniem jest zwrócenie przybliżonego promienia wyrażonego w kilometrach.

Jest to wyzwanie kodowe, w którym wynik składa się z długości kodu (w bajtach) pomnożonej przez współczynnik kar $\ge 1$ , w oparciu o twoje najgorsze przybliżenie. Dlatego wygrywa najniższy wynik .

_{„As we travel the universe” to ostatnia linijka piosenki Planet Caravan autorstwa Black Sabbath , również później ujęta przez Pantera .}

Obiekty Układu Słonecznego

Źródło: Wikipedia

Uwaga: ranga jest podana wyłącznie w celach informacyjnych. Dane wejściowe to nazwa obiektu.

  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

Lub jako przyjazne listy kopiuj-wklej:

'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

Twój wynik

Niech $R_n$ będzie spodziewanym promieniem obiektu $n^{th}$ i niech $A_n$ będzie odpowiedzią twojego programu na ten obiekt.

Następnie twój wynik jest zdefiniowany jako:

gdzie $L$ jest długością twojego kodu w bajtach.

Przykład:

Jeśli Twój kod ma rozmiar $100$ bajtów, a najgorsze przybliżenie dotyczy Księżyca o promieniu szacunkowym $1000$ km zamiast $1737$ km, wynik byłby następujący:

Im niższy, tym lepiej.

Zalecany nagłówek odpowiedzi:

Language, 100 bytes, score = 302

Możesz użyć tego skryptu, aby obliczyć swój wynik (pierwsza linia = długość kodu, kolejne 20 linii = Twoje wyniki, od Sun do Titania).

Zasady

• Możesz wziąć nazwę obiektu w całości małymi lub dużymi literami lub dokładnie tak, jak opisano powyżej (wielkość liter). Inne mieszane przypadki są niedozwolone.
• Gwarantowanym wejściem jest jedna z 20 możliwych nazw.
• Możesz zwrócić liczby całkowite lub zmiennoprzecinkowe. W obu przypadkach kara musi być obliczona bezpośrednio na podstawie tych wartości (nie zaokrąglonych wartości w przypadku liczb zmiennoprzecinkowych).
• Musisz zwrócić wartości dodatnie.
• Puste programy są niedozwolone.

PowerShell , 3 bajty, wynik 3637

2e4

Wypróbuj online!

Bardzo naiwna, nudna, realizacja; zwraca tylko 20000bez względu na dane wejściowe. Eksperymentowanie z takimi rzeczami, jak specjalne osłonięcie słońca lub użycie wartości zmiennoprzecinkowych zamiast 2wszystkich, przyniosło gorsze wyniki, ponieważ długość kodu wzrosła na tyle, aby zrównoważyć wszelkie zyski z porównania wielkości.

Galaretka , 34 bajty, wynik = 37

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

Dane wejściowe są pisane wielkimi literami, moc wyjściowa to 1,1 z najmniejszym błędem.

Wypróbuj online!

Jak to działa

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 bajtów, wynik = 97

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

Wypróbuj online!

• W tym wpisie używane są zarówno nie wyświetlalne, jak i wielobajtowe znaki Unicode (ale Java je akceptuje). Sprawdź TIO pod kątem dokładnego kodu.
• Dane wejściowe muszą być tytułem.
• Ten kod zaokrągla wartości do najlepszej wielokrotności 100 (czasami w górę, czasem w dół), dzięki czemu dwie ostatnie cyfry można pominąć podczas kodowania, a następnie wartość można w przybliżeniu pomnożyć przez 100.
• Ten wpis używa różnych skrótów, aby dopasować ciąg 25 współrzędnych kodowych (najkrótszy ciąg, jaki udało mi się znaleźć).

Kredyty

• Wynik -48 (-45 bajtów) dzięki Kevinowi Cruijssenowi przez bezpośrednie zakodowanie promieni (podzielonych przez 100) Stringzamiast na stałe w wyraźnej inttablicy.

Wolfram Language 114 103 97 88 86 82 bajtów. wynik = 114 103 97 89 87 83 punktów

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

Co najmniej 6 punktów zaoszczędzonych dzięki Dennis, jeszcze kilka dzięki lirtosiasti 6 więcej dziękiuser202729 .

Chociaż Mathematica może pobierać dane z Układu Słonecznego (a także wiele dodatkowych danych astronomicznych), konieczne są pewne drobne poprawki, jak wyjaśniono poniżej.

Interpreter[#,"AstronomicalObject"]&zwróci byt (tj. obiekt obliczalny maszynowo) powiązany z terminem reprezentowanym przez #.

EntityValue[AstronomicalObject[],"Radius"]zwraca promień encji w milach. W przypadku „Haumea” zwracana jest wartość 816,27 (tj. 507 * 1,61).

Mnożenie promienia przez 1.61konwersję z mil na km. Wartości dziesiętne zamiast liczb całkowitych odpowiadają za znacznie mniej niż 1% błędu, nawet w najbardziej ekstremalnych przypadkach.

[[1]]zwraca wielkość bez jednostki, km. Zostało to później zmienione na #&@@, dając ten sam wynik.

Python 3 , wynik 95, 95 bajtów

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

Wypróbuj online!

Python 3 , wynik 133, 133 bajtów

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)

Wypróbuj online!

PowerShell 150 141 bajtów, wynik 163 153

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

Wypróbuj online!

Skrypt testowy:

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

Wynik:

152.731283431953 = 141 * 1.08320059171598

Wyjaśnienie:

• Nazwy zawierają tylko litery, promienie zawierają cyfry i kropki. Możemy więc zapisać wszystkie dane w ciągu danych i przeprowadzić wyszukiwanie wyrażenia regularnego.
• Skrypt wyszukuje wszystkie podciągi od lewej do prawej i pobiera ostatni znaleziony wynik.
• Dane wejściowe muszą być wielkością liter, aby zmniejszyć ciąg danych.
• end of line modeJest tylko LF.

Przykład:

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 bajtów, wynik 178

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

05AB1E , wynik 100 66 60 ( 100 61 56 bajtów )

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

Port odpowiedzi Javy @ OlivierGrégoire , więc jeśli podoba ci się ta pierwsza odpowiedź, pamiętaj, aby go również głosować!
Dane wejściowe w tytule.

Sprawdź wszystkie przypadki testowe.

05AB1E , wynik 100 (100 bajtów )

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

Wprowadzanie pełnymi małymi literami. Podaje dokładny promień, więc nie dodaje się kary.

Sprawdź wszystkie przypadki testowe.

Wyjaśnienie:

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

Zobacz moją wskazówkę 05AB1E (sekcje Jak kompresować duże liczby całkowite? I Jak kompresować ciągi znaków nie częścią słownika? ), Aby zrozumieć, jak działa używana kompresja.

Stworzyłem 70-bajtową alternatywę, która odwzorowałaby słońce 600,000; [Jowisz, Saturn] do 60,000; [uran, neptun] do 30,000; [ziemia, Wenus] do 6,000; [mars, ganymede, titan, rtęć, callisto] do 3,000; [io, moon, europa, triton, pluto, eris] to 1,500; i [haumea; titania] do 750. Niestety uzyskał wynik 117. Zobaczę później, czy uda mi się uzyskać mniej niż 100 przy alternatywnym podejściu.

Mathematica, 57 bajtów, wynik = 62 58

^{-4 bajty / wynik dzięki lirtosiast !}

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

Po prostu sprawdza Wolfram Alpha dla średniego promienia.

Galaretka , 28 bajtów, wynik = 31

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

Wykorzystuje to konfigurowalne wbudowane haszowanie, które dodałem do Jelly na sugestię @ lirtosiast.

Dane wejściowe są w tytule, moc wyjściowa to 1,1 z najmniejszym błędem.

Wypróbuj online!

Jak to działa

Ta odpowiedź składa się tylko z dwóch części.

• Pierwszy, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥ używa nowego wbudowanego do mapowania każdego z 20 możliwych danych wejściowych na 15 różnych liczb całkowitych.
• Następnie 1.1*podnosi 1,1 do mocy obliczeniowej.

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

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

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

Następnie generujemy 64 64-bitowe liczby całkowite poprzez zastosowanie SHAKE256-4096 do reprezentacji ciągu wewnętrznej reprezentacji ḥprawego argumentu, a następnie pocięcie powstałych 4096 bitów na 64 64-bitowe fragmenty.

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

$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$$[0, 15)$ , której używamy do indeksowania listy.

Aby znaleźć odpowiednią konfigurację skrótu, użyłem brutalnego forcera w C, który jest częścią repozytorium Jelly .

Python 2 , 155 bajtów, wynik = 155

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

Wypróbuj online!

Zaskakująco dobre dla tego leniwego rozwiązania ... będzie również poprawiać. ;-)

Japt , 86 bajtów, wynik = 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

Wypróbuj dla wszystkich danych wejściowych , oblicz wynik lub sprawdź najwyższy błąd

Bardzo podobny do oryginalnej odpowiedzi Oliviera. Wszystkie dane są pisane małymi literami.

Po różnych udoskonaleniach wartości wyjściowych bieżącym najwyższym błędem jest Wenus przy nieco ponad 4%.

Wyjaśnienie, że teraz rzeczy są trochę bardziej stabilne:

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

Ciąg nazw jest sujusaurneeavemagatimecaiomoeutrplerhakompresowany przy użyciu wbudowanej kompresji Japt. Liczby reprezentujące promienie są obliczane w następujący sposób:

                          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 bajtów, wynik = 75

Najpierw przejdź; Chciałem wypróbować karę zerową, aby dać sobie punkt wyjścia do pracy. Wrócimy do niego jutro, aby zobaczyć, jakie ulepszenia można wprowadzić, miejmy nadzieję, że nadal za 0 punktów karnych.

Dane wejściowe nie uwzględniają wielkości liter.

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

Spróbuj lub przetestuj wszystkie wejścia

The "..."Reprezentuje ciąg zawierający wiele unprintables. Punkty kodowe to:

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

Aby szybko wyjaśnić: ciąg zostaje podzielony na 2-znakowe części. Następnie indeksujemy do tej tablicy przy użyciu części formuły ovs oraz niektórych zawijania indeksów, a następnie mapujemy 2 znaki na ich współrzędne kodowe.

• Zapisano bajt / punkt dzięki ETH

54 bajty, wynik = 58

Port rozwiązania Oliviera .

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

Przetestuj wszystkie wejścia

Rubinowy , 105 bajtów, wynik 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)}

Wypróbuj online!

Jeśli podzielimy 700000 przez promienie, otrzymamy sekwencję, która rośnie odpowiednio liniowo (choć raczej nierównomiernie). Przyrosty w poniższej tabeli można aproksymować wartościami znaków ASCII. Problem z tym podejściem polega na tym, że wymaga dekodowania danych wejściowych do wartości, która porządkuje różne nazwy według rozmiaru.

Drobny problem polega na tym, że różnica między Eris a Haumeą jest dość duża. ~~dAby zakodować ten przyrost w formacie tylko ASCII, wymagane są trzy znaki . Łańcuch od planety do indeksu ma dwie spacje „planety duchów” do wypełnienia indeksu.

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 bajtów, wynik = 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)

Podziały linii służą wyłącznie do odczytu.

Dane wejściowe są pobierane za pośrednictwem istniejącej tabeli i z kolumną varchar v , zgodnie z naszymi standardami we / wy .

Łączy tabelę wprowadzania z tabelą w pamięci pierwszych dwóch znaków i zwraca pozostałe cyfry x100.

Traktuje „Tytana” jako specjalny przypadek użycia IIF.

EDYCJA : Zapisano 1 bajt (i 1 punkt), używając STUFFdo usunięcia dwóch pierwszych znaków zamiast SUBSTRING. Dzięki, t-clausen.dk!

EDYCJA 2 : Chciałem zobaczyć, co by się stało, gdybym próbował zapisać kolejny bajt, mnożąc każdą wartość wyszukiwania przez 99 zamiast 100, i zdziwiłem się, że faktycznie wzrosła to dokładność (najmniej dokładnego oszacowania) !.

Doprowadziło mnie to do pewnych prób i błędów oraz do niektórych fantazyjnych tabel danych typu „co, jeśli”, w których znalazłem optymalne rozwiązanie przy użyciu mnożnika 89 (co oczywiście zmieniło wszystkie moje przechowywane wartości).

Więc chociaż oszczędza mi to tylko jeden bajt, tak naprawdę poprawia mój wynik o 4,6 w porównaniu z poprzednim rozwiązaniem.

EDYCJA 3 : Wyszukano wyżej zamiast niżej i znalazłem jeszcze lepszy współczynnik mnożenia, 198 . Wartości pozostają w miarę dokładne podczas skracania przechowywanego ciągu o kilka znaków, co poprawia mój wynik.

PowerShell , 203 bajty, wynik 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]

Wypróbuj online!

Bardzo podobny do odpowiedzi Oliviera, teraz kiedy ją widzę, ale rozwinął się niezależnie.

Węgiel drzewny , 101 bajtów, wynik = 101

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

Wypróbuj online!Link jest do pełnej wersji kodu. Wyjaśnienie:

⁺§θ⁰§θχ

Weź 1 i 11 znak (cyklicznie) ciągu wejściowego i połącz je.

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

Sprawdź je w ciągu SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTa podzielonym na pary znaków.

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

Podziel ciąg m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<na grupy po trzy znaki i weź odpowiednią grupę.

Ｉ⍘ ... γ

Zdekoduj wynik jako liczbę podstawową-95, używając zestawu znaków drukowalnych ASCII jako cyfr. Przykład: Iojedenasta postać to I, więc patrzymy w górę IIi stwierdzamy, że jest to 13. największy obiekt, a jego rozmiar jest 31zgodny z mapą 19 * 95 + 17 = 1822.

Szybki 4 , 225 bajtów, wynik = 241

Prawdopodobnie grał w golfa więcej (może w obszarze „Ga-Me-Ca”?), Ale Swift nie jest często używany (może z jakiegoś powodu.)

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

i nie golfił

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

Wypróbuj online!

Próbowałem różnych „kluczowych rozmiarów” mapy, ale oczywiście 1 ma wiele starć, a użycie trzech znaków nie daje mi i=="Titan" ?2575:17 znaków, ponieważ do zarządzania jest „Io” (i zajmie to więcej niż 3 znaki, Myślę).

JavaScript (ES6), 152 bajty, wynik = 163

Cóż, to dość standardowe rozwiązanie, ale i tak mi się podobało!

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

Mój wynik:

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

Wypróbuj online!

FAŁSZ , 152 bajty, wynik = 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!]?

Leniwa odpowiedź przy użyciu długości słów i pierwszych liter, ale usprawiedliwiam się tym, że używam dziwnego języka

Wypróbuj online! (skopiuj wklej kod, naciśnij pokaż, a następnie uruchom)

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

Moje wyniki:

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 bajtów, wynik = 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);}

Wypróbuj online!

Punktacja

Zniszczony

Nazwa obiektu jest przekształcana w hasz jednoznakowy poprzez uciążliwy proces

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

którego wzdęcie wskazuje na „Titan” / „Titania” jako głównych przestępców. Uwzględniono włączenie ostatniej postaci do skrótu, ale nadal wymaga to znakustrlen() znaku C. Pierwsze wystąpienie znaku haszowania jest wyszukiwane w łańcuchu hash / data. Kiedy zostanie znaleziony, następny znak jest pobierany i używany do przybliżenia promienia przedmiotowego obiektu.

Znak danych zawiera przesunięty, skalowany logarytm naturalny promienia. Wygenerowano tak:

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

Skala została wybrana na podstawie wysoce naukowych prób i błędów, a także przesunięcia w celu uwzględnienia wartości w zakresie drukowanego zakresu ASCII przy jednoczesnym unikaniu ukośników odwrotnych. Pewne przegrupowanie obiektów w łańcuchu było konieczne z powodu niektórych kolizji mieszania / danych.

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 bajtów, wynik = 234

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

Wypróbuj online!

Wydaje się, że większość opublikowanych odpowiedzi wykorzystała strategię „kodowania / dekodowania”. Zastanawiałem się, jak dobrze mogę to zrobić, szacując średnicę ciał niebieskich za pomocą prostego równania. To było zabawne ćwiczenie, ale umiarkowane oszczędności w bajtach są więcej niż rekompensowane przez karę za dokładność.

Rdzeniem tego rozwiązania jest równanie szacunkowe:

Radius = 39**4/x**2.18

gdzie x jest dwukrotnością rzędu rangi promienia ciała.

Generuję wartość x na podstawie ciągu wejściowego za pomocą modyfikacji rozwiązania @Erik the Outgolfer's Python 2. Zapisałem kilka bajtów w jego kodzie, przekształcając moje równania do pracy z [2..40] zamiast [1..20].

Kod do generowania zamówień rang zajmuje ponad 2/3 bajtów całego rozwiązania. Jeśli ktoś ma bardziej zwarty sposób generowania rang, rozwiązanie to można jeszcze bardziej skrócić. Z powodu kary za celność (około 2,6) wynik znacznie się poprawił.

Generowanie równania

Użyłem metod statystycznych do wyszukiwania prostych równań w celu oszacowania wielkości każdego ciała na podstawie jego rangi. Po części w oparciu o spostrzeżenia w rozwiązaniu Ruby @Level River St i uogólniając, zdecydowałem się na równania postaci:

Radius = A/(Rank)**B

Pracując w R, użyłem modeli liniowych na logu promieni, aby opracować wstępne szacunki, a następnie zastosowałem optymalizację nieliniową, wypełniając optymalizację wynikami modeli liniowych, aby znaleźć rozwiązania, które zminimalizowały funkcję kary określoną w problem.

Szacunkowa wartość A w powyższym równaniu wynosi siedem cyfr, więc szukałem prostego wyrażenia, aby zapisać kilka bajtów. Szukałem wyrażeń formy

x**y

za dwie cyfry x i 1 cyfrę y (w sumie pięć bajtów, oszczędzając dwa bajty lub około pięciu punktów, biorąc pod uwagę karę), która nie była zbyt różna od optymalnej wartości A i nie zawyżała znacznie kary i zakończyła się w górę z (poza tym niewytłumaczalne):

39**4

TI-BASIC (TI-84), 285 bajtów, wynik = 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

Prosty program „indeks w ciągu do listy”. Można dalej grać w golfa.

Wejście jest w Ansi jest jednym z nazw obiektów dużymi literami.
Wyjście jest włączone Ansi jest automatycznie drukowane.

Przykład:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

Objaśnienie:
(Lista promieni i ciąg nazwy zostały skrócone dla zwięzłości. ...Służy do wskazania reszty listy / ciągu).

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

Model wizualny:

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