태양계에서 가장 큰 20 개의 물체 중 하나의 이름이 주어집니다. 당신의 임무는 반경의 근사치를 킬로미터 단위로 반환하는 것입니다.

이것은 점수 가 당신의 최악의 근사값을 기준으로 페널티 비율 곱한 코드 길이 (바이트)로 구성되는 코드 도전 입니다. 따라서 최저 점수가 이깁니다 .$\ge 1$

_{"우리가 우주를 여행 할 때"는 검은 안식일에 의한 플래닛 캐러밴 의 마지막 줄이며 , 나중에 판테라에 의해 덮힌 다 .}

태양계 물체

출처 : Wikipedia

주의 : 순위는 정보 제공만을위한 것입니다. 입력은 객체 의 이름 입니다.

  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

또는 복사하여 붙여 넣기하기 쉬운 목록으로 :

'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

너의 점수

하자 의 예상 반경 수 개체 및하자 이 객체에 대한 프로그램의 해답이 될 수.$R_n$$n^{th}$$A_n$

그런 다음 점수는 다음과 같이 정의됩니다.

여기서 은 코드 길이 (바이트)입니다.$L$

예:

코드의 크기가 바이트이고 최악의 근사치가 대신 의 추정 반경으로 달에있는 경우 점수는 다음과 같습니다.$100$$1000$$1737$

낮을수록 좋습니다.

답변을위한 권장 헤더 :

Language, 100 bytes, score = 302

당신이 사용할 수있는 이 스크립트를 (일에서 티타니아에 첫 번째 줄 = 코드 길이, 향후 20 개 라인 = 당신의 출력) 점수를 계산합니다.

규칙

• 소문자, 전체 대문자 또는 위에서 설명한대로 정확히 제목 (제목)으로 개체 이름을 사용할 수 있습니다. 다른 혼합 사례는 허용되지 않습니다.
• 입력은 20 개의 가능한 이름 중 하나가 보장됩니다.
• 정수 또는 부동 소수점을 반환 할 수 있습니다. 두 경우 모두 패널티는 이러한 값을 사용하여 직접 계산해야합니다 (부동의 경우 반올림 값이 아님).
• 양수 값을 반환해야합니다.
• 빈 프로그램은 허용되지 않습니다.

PowerShell , 3 바이트, 3637 점

2e4

온라인으로 사용해보십시오!

매우 순진하고 지루한 구현; 20000입력에 관계없이 반환합니다 . 태양을 특수하게 배치하거나 2모두 대신 부동 소수점 값을 사용하는 것과 같은 실험을 수행 하면 코드 길이가 크기 비교 이득을 상쇄하기에 충분하게 증가했기 때문에 점수가 떨어졌습니다.

젤리 , 34 바이트, 점수 = 37

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

입력은 대문자이며 출력은 최소 1.1의 거듭 제곱입니다.

온라인으로 사용해보십시오!

작동 원리

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 바이트, 점수 = 97

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

온라인으로 사용해보십시오!

• 이 항목은 표시 할 수없고 멀티 바이트 유니 코드 문자를 모두 사용합니다 (그러나 Java는이를 허용합니다). 정확한 코드는 TIO를 확인하십시오.
• 입력은 제목 케이스 여야합니다.
• 이 코드는 인코딩 할 때 마지막 두 자리를 건너 뛸 수 있고 값을 100으로 곱하여 근사 할 수 있도록 값을 최고 100의 배수 (때로는 위, 때로는 아래로)로 반올림합니다.
• 이 항목은 다양한 해시를 사용하여 25 코드 포인트 문자열 (찾을 수있는 가장 짧은 문자열)에 맞습니다.

크레딧

• Kevin Cruijssen 덕분에 반지름 (100으로 나눈 값)을 String명시적인 int배열 로 하드 코딩 하는 대신 직접 인코딩하여 -48 점 (-45 바이트) .

Wolfram Language 114103 97 88 86 82 바이트. 점수 = 114103 97 89 87 83 점

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

덕분에 6 점 이상 Dennis, 덕택에 6 점 이상, 6 점 lirtosiast이상이 추가되었습니다 user202729.

Mathematica는 태양계 데이터 (많은 추가 천문학적 데이터)를 가져올 수 있지만, 아래 설명과 같이 약간의 조정이 필요합니다.

Interpreter[#,"AstronomicalObject"]&로 표시되는 용어와 관련된 엔터티 (즉, 컴퓨터 계산 가능 개체)를 반환합니다 #.

EntityValue[AstronomicalObject[],"Radius"]엔터티의 반경 (마일)을 반환합니다. "Haumea"의 경우 816.27 (즉 507 * 1.61) 값이 반환됩니다.

반경 1.61을 마일로 곱하면 마일에서 킬로미터로 변환됩니다. 가장 극단적 인 경우에도 정수가 아닌 10 진수 값이 1 % 미만의 오류를 차지합니다.

[[1]]단위없이 km를 반환합니다. 이것은 나중에로 변경되어 #&@@동일한 결과를 얻었습니다.

파이썬 3 , 점수 95, 95 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 점수 133, 133 바이트

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)

온라인으로 사용해보십시오!

파워 쉘은 150 141 바이트, 골 (163) (153)

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

온라인으로 사용해보십시오!

테스트 스크립트 :

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

산출:

152.731283431953 = 141 * 1.08320059171598

설명:

• 이름에는 문자 만 포함되며 반지름에는 숫자와 점이 포함됩니다. 따라서 모든 데이터를 데이터 문자열로 작성하고 정규식 검색을 수행 할 수 있습니다.
• 스크립트는 왼쪽에서 오른쪽으로 모든 하위 문자열을 검색하고 마지막으로 찾은 결과를 가져옵니다.
• 데이터 문자열을 줄이려면 입력이 제목 대소 문자 여야합니다.
• 는 end of line mode단지 LF입니다.

예:

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 바이트, 178 점

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

05AB1E , 점수 100 66 60 ( 100 61 56 바이트 )

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

@ OlivierGrégoire 의 Java 답변 포트 이므로이 첫 번째 답변이 마음에 드시면 그를 찬성 해야합니다!
제목 케이스에 입력하십시오.

모든 테스트 사례를 확인하십시오.

05AB1E , 점수 100 (100 바이트 )

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

전체 소문자로 입력하십시오. 정확한 반경을 출력하므로 페널티가 추가되지 않습니다.

모든 테스트 사례를 확인하십시오.

설명:

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

내이 05AB1E 팁을 참조하십시오 (섹션에서는 어떻게 큰 정수를 압축하는 데 어떻게? 와 어떻게 문자열을 사전의 일부를 압축? ) 방법 압축 사용 작품을 이해하기.

나는 태양을 매핑하는 70 바이트 대안을 만들었습니다 600,000. [목성, 토성] ~ 60,000; [우라누스, 해왕성]에서 30,000; [지구, 금성] ~ 6,000; [mars, ganymede, 티탄, 수은, callisto] ~ 3,000; [io, moon, europa, triton, pluto, eris] ~ 1,500; 및 [haumea; titania] ~ 750. 불행히도 그것은 117 점을 얻었습니다. 나중에 다른 방법으로 100 이하로 갈 수 있는지 알 수 있습니다.

Mathematica, 57 바이트, 점수 = 62 58

^{lirtosiast 덕분에 -4 바이트 / 점수 !}

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

Wolfram Alpha는 평균 반경을 검색합니다.

젤리 , 28 바이트, 점수 = 31

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

이것은 @lirtosiast의 제안에서 Jelly에 추가 한 구성 가능한 해싱 내장 기능을 사용합니다.

입력은 제목이며, 출력은 최소 1.1의 거듭 제곱입니다.

온라인으로 사용해보십시오!

작동 원리

이 답변은 단지 두 부분으로 구성됩니다.

• 먼저, “__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘ḥ새로운 내장 기능을 사용하여 20 개의 가능한 입력 각각을 15 개의 다른 정수에 매핑합니다.
• 그런 다음 1.1*계산 된 전력으로 1.1을 올립니다.

“__ʋ7ṗ“RUu⁽NM\sOSJj[FL‘리터럴입니다. 따옴표가 아닌 모든 문자는 Jelly의 코드 페이지에서 0 기반 인덱스로 대체되어 .$[95, 95, 169, 55, 242], [82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$

내장 해싱은 ḥ먼저 각 숫자를 증분하여 를 정수로 매핑 한 다음 결과를 bijective base-250 자리 정수로 처리하고 합니다. 이 결과는 입니다.$[95, 95, 169, 55, 242]$$1$$376510639244$

양분과 결과가 될 때까지이 정수 바닥재으로 , 우리는 시퀀스를 얻을 , 순방향 차이를 갖는 .$0$$[376510639244, 188255319622, 94127659811, 47063829905, \dots, 5, 2, 1, 0]$$[188255319622, 94127659811, 47063829906, \dots, 3, 1, 1]$

다음으로 SHAKE256-4096 을 ḥ올바른 인수 의 내부 표현의 문자열 표현 에 적용한 다음 결과 4096 비트를 64 개의 64 비트 청크로 자릅니다.

ḥ이제 39 개의 차이와 첫 번째로 생성 된 64 비트 정수인 modulo 의 내적을 계산합니다 . 의 정수가됩니다 .$2^{64}$$[0, 2^{64})$

리스트 는 길이가 15이므로 생성 된 정수에 15를 곱하고 64를 더 높게 취합니다. 결과의 비트. 이것은 의 정수를 산출 하는데, 우리는리스트에 색인을 생성하는데 사용합니다.$[82, 85, 117, 141, 78, 77, 92, 115, 79, 83, 74, 106, 91, 70, 76]$$[0, 15)$

적절한 해시 구성을 찾기 위해 Jelly repo의 일부인 C에서 brute-forcer를 사용했습니다 .

파이썬 2 , 155 바이트, 점수 = 155

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

온라인으로 사용해보십시오!

이 게으른 해결책에 놀랍게도 ... 개선도 기대할 것입니다. ;-)

Japt , 86 바이트, 점수 = 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

모든 입력을 위해 그것을 시도 , 점수를 계산 , 또는 가장 높은 오류를 확인

Olivier의 원래 답변과 매우 유사합니다. 입력은 모두 소문자입니다.

출력 값을 다양하게 개선 한 후 현재 가장 높은 오류는 4 % 이상의 금성입니다.

이제 상황이 조금 더 안정적임을 설명하십시오.

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

이름의 문자열은 sujusaurneeavemagatimecaiomoeutrplerhaJapt의 내장 압축을 사용하여 압축됩니다. 반지름을 나타내는 숫자는 다음과 같이 계산됩니다.

                          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

apt, 77 76 75 바이트, 점수 = 75

먼저 이것을 통과하십시오. 나는 스스로에게 기준을 제공하기 위해 0 페널티 솔루션을 시도하고 싶었습니다. 내일 다시 돌아와 개선이 가능한지 확인하십시오.

입력은 대소 문자를 구분하지 않습니다.

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

사용해 보거나 모든 입력을 테스트하십시오

는 "..."많은 unprintables 포함 된 문자열을 나타냅니다. 코드 포인트는 다음과 같습니다.

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

빠른 설명을 제공하기 위해 : 문자열은 2 문자로 분할됩니다. 그런 다음 ovs 수식의 일부와 인덱스 래핑을 사용하여 해당 배열에 색인을 생성 한 다음 2 개의 문자를 해당 코드 점에 매핑합니다.

• ETH 덕분에 바이트 / 포인트 절약

54 바이트, 점수 = 58

올리비에 솔루션 포트 .

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

모든 입력 테스트

루비 , 105 바이트, 점수 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)}

온라인으로 사용해보십시오!

700000을 반지름으로 나눈다면 우리는 합리적으로 선형 적으로 증가하는 시퀀스를 얻습니다. 아래 표의 증분은 문자의 ASCII 값으로 근사 할 수 있습니다. 이 방법의 문제점은 입력을 크기별로 다른 이름으로 정렬하는 값으로 디코딩해야한다는 것입니다.

사소한 문제는 Eris와 Haumea의 차이가 상당히 크다는 것입니다. ~~d이 증분을 ASCII 전용 형식으로 인코딩하려면 세 개의 문자 가 필요합니다. 행성 간 색인 문자열에는 색인을 채우는 두 개의 "유령 행성"공간이 있습니다.

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 바이트, 점수 = 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)

줄 바꿈은 읽기 쉬운 것입니다.

입력은 기존의 테이블을 통해 촬영 전 varchar 열로 V , 우리의 IO의 기준에 따라 .

입력 테이블을 처음 두 문자의 메모리 내 테이블에 조인하고 나머지 숫자 x100을 반환합니다.

를 사용하여 "Titan"을 특수한 경우로 취급합니다 IIF.

편집 : STUFF대신 첫 두 문자를 지우는 데 사용하여 1 바이트 (및 1 포인트)를 저장했습니다 SUBSTRING. 감사합니다, t-clausen.dk!

편집 2 : 각 조회 값에 100 대신 99를 곱하여 다른 바이트를 저장하려고하면 어떻게 될지 알고 싶었습니다. 실제로 정확도 가 가장 낮습니다 (최소 정확한 추정치) !.

이로 인해 시행 착오 테스트와 멋진 Excel what-if 데이터 테이블이 생겨 89 의 승수를 사용하여 최적의 솔루션을 찾았습니다 (물론 모든 저장된 값이 변경되었습니다).

따라서 이것은 하나의 바이트 만 절약하지만 실제로 이전 솔루션에서 점수를 4.6 향상시킵니다 .

편집 3 : 낮게 검색하지 않고 더 높게 검색했으며 더 나은 곱셈 계수 198을 찾았습니다 . 저장된 문자열을 몇 자씩 줄이면서 값이 합리적으로 정확하여 점수가 향상됩니다.

PowerShell , 203 바이트, 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]

온라인으로 사용해보십시오!

Olivier의 답변과 매우 유사하지만 이제는 알지만 독립적으로 개발했습니다.

숯 , 101 바이트, 점수 = 101

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

⁺§θ⁰§θχ

입력 문자열의 첫 번째와 11 번째 문자를 주기적으로 가져 와서 연결하십시오.

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

문자열 SuJiSrUuNtEEVVMrGnTTMcClIIMoEpToPPEiHeTa을 문자 쌍으로 분리하여 찾아 보십시오 .

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

문자열 m.w'fv&J|\"l|\"e1 c& _c Ca ;e ;* 9a 9C 31 2; 0I .7 ,N ,7 (X (<을 세 문자 그룹으로 나누고 해당 그룹을 가져옵니다.

Ｉ⍘ ... γ

인쇄 가능한 ASCII 문자 세트를 숫자로 사용하여 결과를 기본 95 숫자로 디코딩하십시오. 예 : Io11 번째 문자는 I이므로 II13 번째로 큰 물체이며 크기는 31로 매핑됩니다 19 * 95 + 17 = 1822.

스위프트 4 , 225 바이트, 점수 = 241

아마 "Ga-Me-Ca"지역에서 더 많은 골프를 즐길 수 있지만 Swift는 자주 사용되지 않습니다 (이유로 인해).

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

그리고 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
  )
}

온라인으로 사용해보십시오!

지도에 대해 다른 "키 크기"를 시도했지만 물론 1은 많은 충돌이 있으며 3 개의 문자를 사용 i=="Titan" ?2575:하면 관리 할 "Io"가 있으므로 3 개의 문자를 사용하면 17 개의 문자가 표시되지 않습니다 . 생각합니다).

자바 스크립트 (ES6), 152 바이트, 점수 = 163

글쎄, 그것은 꽤 표준적인 솔루션이지만 어쨌든 도전을 즐겼습니다!

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

내 점수:

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

온라인으로 사용해보십시오!

FALSE , 152 바이트, 점수 = 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!]?

단어 길이와 첫 글자를 사용하여 게으른 대답이지만 변명은 이상한 언어를 사용하고 있다는 것입니다.

온라인으로 사용해보십시오! (코드를 복사하여 붙여 넣고 쇼를 누른 다음 실행하십시오)

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

내 결과 :

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 바이트, 점수 = 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);}

온라인으로 사용해보십시오!

채점

개요

번거로운 프로세스를 통해 객체 이름이 단일 문자 해시로 바뀝니다.

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

부 풀리는 사람이 주요 범죄자로 "Titan"/ "Titania"를 가리 킵니다. 해시의 마지막 문자를 포함하는 것이 고려되었지만 여전히 strlen()C 가 필요합니다 . 해시 문자의 첫 번째 발생은 해시 / 데이터 문자열에서 검색됩니다. 발견되면 다음 문자를 가져와 해당 객체의 반경을 근사화하는 데 사용됩니다.

데이터 문자는 반경의 이동 된 스케일 된 자연 로그를 보유합니다. 다음과 같이 생성됩니다.

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

이 척도는 고도로 과학적인 시행 착오와 백 슬래시를 피하면서 인쇄 가능한 ASCII 범위 내에서 값을 가져 오는 변화를 통해 선택되었습니다. 해시 / 데이터 충돌로 인해 문자열의 객체를 다시 정렬해야했습니다.

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

파이썬 2 , 89 바이트, 점수 = 234

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

온라인으로 사용해보십시오!

게시 된 대부분의 답변은 "인코딩 / 디코딩"전략을 사용한 것으로 보입니다. 간단한 방정식을 사용하여 천체의 지름을 추정하여 얼마나 잘 할 수 있을지 궁금했습니다. 그것은 재미있는 운동 이었지만, 적당한 바이트 절약은 정확성 페널티에 의해 보완되는 것 이상입니다.

이 솔루션의 핵심은 추정 방정식입니다.

Radius = 39**4/x**2.18

여기서 x는 몸통 반지름 순위의 두 배입니다.

Outgolfer의 Python 2 솔루션 @Erik의 수정을 사용하여 입력 문자열을 기반으로 x 값을 생성합니다. [1..20] 대신 [2..40]과 함께 작동하도록 방정식을 다시 변환하여 코드에 몇 바이트를 저장했습니다.

순위 순서를 생성하기위한 코드는 전체 솔루션 바이트의 2/3 이상을 차지합니다. 계급을 생성하는보다 간단한 방법을 가진 사람이라면이 솔루션을 더 단축 할 수 있습니다. 정확도 패널티 (2.6 정도) 때문에 점수가 약간 향상됩니다.

방정식 생성

통계적 방법을 사용하여 간단한 방정식을 검색하여 순위에 따라 각 신체의 크기를 추정했습니다. @Level River St의 Ruby 솔루션에 대한 통찰력과 일반화에 대해 부분적으로 다음과 같은 형식으로 정리했습니다.

Radius = A/(Rank)**B

R에서 일하면서 반경의 로그에 선형 모델을 사용하여 초기 추정치를 개발 한 다음 선형 모델의 결과로 최적화를 시드하는 비선형 최적화를 사용하여 문제.

위의 방정식에서 A의 예상 값은 7 자리이므로 몇 바이트를 저장하는 간단한 표현식을 검색했습니다. 나는 형태의 표현을 찾았다

x**y

A의 최적 값과 너무 다르지 않고 벌점을 크게 팽창시키지 않은 2 자리 x 및 1 자리 y (총 5 바이트, 2 바이트 저장 또는 약 5 점) (그렇지 않으면 설명 할 수없는)

39**4

TI-BASIC (TI-84), 285 바이트, 점수 = 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

간단한 "문자열 인덱스"프로그램. 더 골프를 칠 수 있습니다.

입력은 Ans대문자로 된 개체 이름 중 하나입니다.
출력이 시작 Ans되고 자동으로 인쇄됩니다.

예:

"MOON
MOON
prgmCDGFC
            1737
"IO
IO
prgmCDGFC
            1822

설명 :
(Radii 목록 및 이름 문자열은 간결성을 위해 단축되었습니다. ...나머지 목록 / 문자열을 나타내는 데 사용됩니다.)

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

비주얼 모델 :

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