“当我们穿越宇宙时……”

48

您将获得太阳系中20个最大物体之一的名称。您的任务是返回半径的近似值，以公里为单位。

这是一种代码挑战，根据最差的近似值，您的分数包括代码长度（以字节为单位）乘以惩罚比。因此，最低分获胜。≥1

“我们在宇宙中旅行”是Black Sabbath演唱的《Planet Caravan》的最后一句，后来也被Pantera演唱。

太阳系物体

资料来源：维基百科

注意：排名仅供参考。输入是对象的名称。

  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

你的分数

令为第对象的期望半径，令为该对象的程序的答案。RnnthAn

然后您的分数定义为：

S=⌈L×max1≤i≤20(max(AiRi,RiAi)2)⌉

其中是代码的长度（以字节为单位）。L

例：

如果代码的大小为字节，而您最差的近似值是在月球上，则估计半径为公里而不是公里，那么您的分数将是：10010001737

S=⌈100×(17371000)2⌉=302

越低越好。

推荐答案的标题：

Language, 100 bytes, score = 302

您可以使用此脚本来计算分数（第一行=代码长度，接下来的20行=输出，从Sun到Titania）。

规则

  • 您可以使用全小写字母，全大写字母或完全如上所述的名称（标题大小写）来获取对象的名称。不允许其他混合情况。
  • 输入内容保证为20个可能的名称之一。
  • 您可以返回整数或浮点数。在这两种情况下，必须直接使用这些值来计算罚分（对于浮点数，则不能四舍五入）。
  • 您必须返回正值。
  • 不允许使用空程序。
code-challenge  approximation 
— Arnauld
source
2
沙箱（现已删除）。感谢所有提供反馈的人，尤其是xnor帮助解决计分公式的问题。
— Arnauld
1
我看到差异的得分已更改为2的幂？在那种情况下，我的100个字节的确切答案比我的70个字节的近似值短（之前的
— 分数
1
@KevinCruijssen背后的想法是防止极短的答案（基本上返回1或2个常量）受到合理因素的惩罚，并有可能与更复杂的答案相提并论。
— Arnauld
2
我赞成评分功能中的平方。我以前的最佳结果是使用2个字节获得7512所有测试用例的得分为60 。我将看到我是否会很快着手创建MathGolf解决方案，但是很难击败05AB1E。
— maxb
2
@maxb您必须击败Jelly的37分，而不是05AB1E的60分； p
— Kevin Cruijssen

Answers:

28

PowerShell，3个字节，得分3637

2e4

在线尝试！

非常幼稚，无聊，执行；20000无论输入如何，都只返回。对特殊的太阳进行试验或使用浮点值而不是2全部值进行试验会导致得分更差，因为代码的长度增加到足以抵消任何尺寸比较的收益。

— AdmBorkBork
source
3
这就是您需要了解的KPI的全部信息：）
— mazzy
12
为什么得到这么多的选票？！
— 毛茸茸的
11
@Shaggy我对此也感到困惑..：S到目前为止，这是最懒惰和得分最高的答案（不要认为它是个人的AdmBorkBork，但我认为Jelly和Java答案值得更多赞扬）。人们可能只看到3个字节的部分（或者认为分数越高分越好），而忽略了其他所有内容。xD在Arnauld在“沙盒”中最初的挑战描述中，甚至不可能提供此答案，因为它允许每个I / O的最大错误百分比为95％。呃，好吧。享受免费代表AdmBorkBork。;）
— Kevin Cruijssen
6
它确实符合问题的标准。我认为人们投票是因为它很明显，很多人都没有考虑过。如果可以以这种方式滥用评级系统，这也意味着挑战评级系统。
— 艾尔坎（Elcan）
9
人们出于各种原因对PPCG表示支持，而不仅仅是因为原始分数（例如，请参阅我的Minecraft红石答案）。我赞成这个答案，因为它是策略范围的一个清晰，简单的例子（“返回精确值”与“保存字节以返回近似值并采取惩罚”之间的范围）。
— BradC
25

果冻，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
— 丹尼斯
source
20

Java（JDK），90个字节，分数= 97

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

在线尝试！

  • 此项使用不可显示的和多字节的Unicode字符（但是Java仍然接受它们）。检查TIO以获取正确的代码。
  • 输入的内容必须为大写字母。
  • 此代码将值四舍五入为最佳的100的倍数（有时向上，有时向下），以便在编码时可以跳过最后两位，然后可以乘以100来近似该值。
  • 此项使用各种散列来容纳25个代码点字符串（我能找到的最短字符串）。

学分

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source
3
— 凯文·克鲁伊森
谢谢@KevinCruijssen！这是一个不错的选择，在字符串中使用unicode字符而不是十进制值数组。:-)
— OlivierGrégoire18年
很高兴我可以提供帮助，而且回答很好！:) PS：至于我为什么添加(...-7)：：无法打印的字符(char)0为空，所以我必须添加一些内容。我首先尝试9并8成为一位数字，但9给出了当然的制表符，需要多个\t（每个2个字节），并且8给出了有关所使用的未转义字符的错误。
— 凯文·克鲁伊森
@KevinCruijssen说实话，昨天我尝试了几个小时，通过将乘积扩展*100-700为字符串值和这两个数字并使用它们来获得更好的值 ，但实际上是最好的，有些值可以减少字节数计数，但分数保持不变。因此，随机定位是最好的情况之一；）
— OlivierGrégoire18年
谈论不可显示！此项真的使我的Firefox感到奇怪，以至于我实际上无法正确阅读页面的其余部分：-(
— Neil
9

Wolfram语言114 103 97 88 86 82字节。得分= 114103 97 89 87 83分

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

至少有6个保存的感谢Dennis，几个感谢lirtosiast和6个感谢user202729。

尽管Mathematica可以获取太阳系数据（以及许多其他天文数据），但仍需要进行一些细微调整，如下所述。

Interpreter[#,"AstronomicalObject"]&将返回与所代表的术语相关联的实体（即机器可计算对象）#。

EntityValue[AstronomicalObject[],"Radius"]返回实体的半径（以英里为单位）。在“ Haumea”的情况下，返回值816.27（即507 * 1.61）。

半径乘以可1.61将英里转换为公里。即使在最极端的情况下，十进制值（而不是整数）也可以使错误率大大低于1％。

[[1]]返回不带单位km的大小。后来将其更改为#&@@，得到相同的结果。

— 戴维
source
1
内置了另一个Wolfram。就像检测下降的
— 东西
我会回答的，但我不知道
— Wolfram
实际上，这也需要互联网连接（在10.2上测试）
— user202729 '18
@ user202729，您的最后两个有用的建议现已集成。使用诸如天文物体之类的实体确实需要互联网连接。
— DavidC
1
gh，半径的默认单位是英里？至少它具有质量的理智（即公制）默认单位...
— 尼尔
7

Python 3，得分95，95字节

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

在线尝试！

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

在线尝试！

— ovs
source
6

的powershell，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

说明：

  • 名称仅包含字母，半径包含数字和点。因此，我们可以将所有数据写入数据字符串并执行regexp搜索。
  • 该脚本从左到右搜索所有子字符串，并获取找到的最后结果。
  • 输入必须为大写字母，以减少数据字符串。
  • 该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]
— 疯狂的
source
4

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字节的替代方案，该方案将sun映射到600,000；[木星，土星]到60,000；[天王星，海王星]到30,000; [地球，金星]到6,000; [火星，木卫三，钛，汞，木卫四]到3,000; [io，moon，europa，triton，pluto，eris]至1,500；和[haumea; titania]至750。不幸的是，满分为117。我将看看以后是否可以使用其他方法将其降至100以下。

— 凯文·克鲁伊森
source
1
我发现了一个更好的哈希，它使用25个字符的字符串而不是30个字符的字符串。检查我的Java答案是否要更新此答案；）
— OlivierGrégoire18年
@OlivierGrégoire感谢您的单挑。-6分和-7个字节。:)
— Kevin Cruijssen
4

Mathematica，57个字节，得分 = 62 58

-4字节/分数感谢lirtosiast！

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

Wolfram Alpha只是查找平均半径。

— 军团哺乳动物978
source
1
嗯 这不算是使用互联网吗？除非Mathematica实际上包含整个WolframAlpha引擎
— 仅使用ASCII
@ ASCII-只有我的意思是，Mathematica的数据集被允许，并且WolframAlpha功能已被使用的 至少 4 倍 ...
— LegionMammal978
嗯 似乎有点像一个任意决定，是什么在阻止其他语言添加搜索引擎功能？国际海事组织数据集是有点不同-下载所有的就是这么大规模的在需要时中央服务器把它交给你
— ASCII-仅
仅@ASCII如果您担心，可以随时在Meta上发布问题。
— LegionMammal978
@leg在这种情况下，下载后可以脱机使用数据。在这种情况下，不是。
— user202729 '18
4

果冻，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‘[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，…，5，2，1个，0][188255319622，94127659811，47063829906，…，3，1个，1个]

接下来，我们通过将SHAKE256-4096应用于ḥright参数的内部表示形式的字符串表示形式，生成64个64位整数，然后将所得的4096位切成64个64位块。

ḥ264[0，264）

[82，85，117，141，78，77，92，115，79，83，74，106，91，70，76][0，15）

为了找到合适的哈希配置，我在C 中使用了Jelly repo的一部分的暴力破解工具。

— 丹尼斯
source
3

Python 2，155个字节，分数 = 155

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

在线尝试！

令人惊讶的是，对于这种懒惰的解决方案……还将寻求改进。;-)

— 暴民埃里克
source
3

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

尝试所有输入，计算分数或检查最高误差

与奥利维尔的原始答案非常相似。输入全部为小写。

在对输出值进行各种改进之后，当前最大的误差是维纳斯，刚好超过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

名称的字符串是sujusaurneeavemagatimecaiomoeutrplerha使用Japt的内置压缩功能压缩的。代表半径的数字的计算方式如下：

                          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）
source
3

Japt，77 76 75字节，分数= 75

第一次通过 我想尝试采用0罚球的解决方案，以给自己一个可以解决的基线。明天再回来看看有什么可以改进的地方，希望还是要加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

测试所有输入

— 毛茸茸
source
我想你可以通过移动第一项（＃23），其所属的地方结束，除去节省字节%24:-)
— ETHproductions
@ETHproductions，似乎不起作用
— Shaggy
— ETHproductions '18
@ETHproductions：嗯，是的，只是告诉自己我需要在数组的开头添加一个占位符元素。谢谢。
— 毛茸茸的
3

Ruby，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格式将此增量编码，需要三个字符。Planet-to-index字符串中有两个“ ghost planet”空间以填充索引。

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
— 水准河圣
source
3

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)

换行符仅供阅读。

根据我们的IO标准，通过已存在的表i和varchar列v进行输入。

将输入表连接到前两个字符的内存表中，并返回剩余的数字x100。

使用将“ Titan”视为特例IIF。

编辑：通过使用STUFF来擦除前两个字符，节省了1个字节（和1个点）SUBSTRING。谢谢，t-clausen.dk！

编辑2：我想看看如果我尝试通过将每个查找值乘以99而不是100来保存另一个字节，将会发生什么，令我惊讶的是，它实际上提高了（最不准确的估算值）的准确性！

这导致我进行了一些反复试验和测试，并创建了一些花哨的Excel假设数据表，在这些表中，我找到了使用89的乘数的最佳解决方案（这当然改变了我所有的存储值）。

因此，虽然这只节省了我一个字节，但实际上比以前的解决方案提高了4.6分。

编辑3：搜寻更高而不是更低，发现乘积系数甚至更高198。值保持相当准确，同时将我存储的字符串缩短了几个字符，这提高了我的得分。

— 布拉德
source
1
您可以使用STUFF（value，1,2，''）代替子字符串保存1个字节
— t-clausen.dk
2

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]

在线尝试！

现在我看到了，它与奥利维尔的答案非常相似，但是是独立开发的。

— AdmBorkBork
source
1

木炭，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为底的数字。示例：Io的第11个字符是I，因此我们向上II查找并发现它是第13个最大的对象，并且其大小31映射到19 * 95 + 17 = 1822。

— 尼尔
source
1

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

和无高尔夫球

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:17个字符，因为要管理“ Io”（而且需要3个以上的字符，我认为）。

— 西蒙妮·切洛（Simone Chelo）
source
1

JavaScript（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

在线尝试！

— ru
source
1

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
— 特耶伯
source
1634
我将其更新为使用1822年的一半（911），而我可以为Haumea做一个特殊情况，因此此建议不再起作用。我尝试使用817（1634年上半年），但效果不佳。如果您想发挥自己的魔力并找到新的最佳数字，那就放心了。
— Terjerber '18
1

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
— 腹肌
source
0

Python 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的值。通过重现方程以使用[2..40]而不是[1..20]，我在他的代码上节省了一些字节。

用于生成等级顺序的代码占用了整个解决方案字节的2/3以上。如果任何人都有更紧凑的排名生成方式，则可以进一步缩短此解决方案。由于精度下降（大约2.6），因此得分会大大提高。

产生方程式

我使用统计方法搜索简单的方程式，以根据其排名估算每个物体的大小。在跟进@Level River St的Ruby解决方案的见解并进行概括时，我决定采用以下形式的方程式：

Radius = A/(Rank)**B

在R中工作时，我使用了半径对数上的线性模型来开发初始估计，然后使用非线性优化，将线性模型的结果作为优化的种子，以寻找最小化方程中指定的罚函数的解。问题。

上式中A的估计值为7位数字，因此我搜索了一个简单的表达式以节省几个字节。我在寻找形式的表达

x**y

对于两位数的x和一位数的y（总共5个字节，节省2个字节，或大约5点，给定罚金），它与A的最佳值相差不大，并且没有使罚分膨胀得太多，因此结束与（否则莫名其妙）：

39**4
— CCB60
source
计分算法似乎确实伤害了该方法-我猜想在L2或L1的错误准则下，该算法会更好。尽管您仍然浪费字节存储名称。
— lirtosiast
@lirtosiast同意这两点。有趣的是，在这种评分算法下，最小二乘拟合（L2范数）也相当不错。它比我发现的最佳方程式仅差约5％。关于存储名称：我想不出一种更紧凑的方法来从文本输入生成数字的升序。其他答案中采用的模算法方法使顺序随机化。
— CCB60
0

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

说明：（
为简化起见，缩短了半径列表和名称字符串。...用于指示列表/字符串的其余部分。）

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
— 头
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.