多功能整数打印机


93

编写一段至少可以用三种不同语言执行的代码。代码必须输出第一1语言,第二2语言,3第三语言等的整数。

规则:

  • 输出必须仅是整数,但结尾的换行符可以。
  • 该代码不能接受任何形式的输入
  • 同一语言的不同主要版本被认为是唯一的。因此,您的代码可以在Python 2和Python 3中执行,但是Python 2.5和Python 2.7并不是唯一的。
  • 您可以使用一种新语言,前提是该语言具有esolang / wiki文章,可用的解释器和文档,并且在用于此挑战之前已被至少两个用户在PPCG上使用。它还必须遵守这4条规则

提交的分数是代码中的字节数除以可以在多维数据集中运行的语言数。因此,可以以3种语言执行的54字节解决方案得分为2:

54 / 3^3 = 2  

分数越低越好。


排行榜


6
@muddyfish您可能能够获取的代码中的次要版本,然后会给你所有的免费解决方案2.7.12.7.n。(实际上,sweerpotato仅在主要版本中做到这一点。)
Martin Ender

14
我认为也许用语言的最短解决方案在这里没有意义...:P
FryAmTheEggman 2015年

3
@Mego我也不是,这就是为什么我对这个问题留下讽刺的评论,以便其他人发现它:P
FryAmTheEggman 2015年

12
我只是想祝贺您得分的平衡。当代码挑战将两个数量混合成一个分数时,平衡几乎总是不平衡,因此最佳答案只会优化其中一个分数,而根本不必考虑另一个。在这里,语言数量的立方重是完美的。。。尽管总是可以添加另一种语言,但这样做总是一个非常好的(但可行的)挑战,因为它只能提供可用的字节数。:)
Martin Ender

20
这个PPCG挑战中,我们一直在合作构建多语言。与在此挑战中提交的主要参赛作品相比,它现在在该挑战中的得分更高,但是复制不断改进的团队努力没有任何意义,因此,我在此处的评论中仅提及一小部分。

Answers:


90

30种语言,248个字节,248/30 ^ 3 = 0.009185

#|#?15g,@           kkmNmSaIeoe99+{\#/-;n@0ea
#[9!@>.>.eeaww#-1@*"12" L
#{  
###
#`{
25
print(4^2 +7)/2


"""
Jo is here.
$'main'MoO OOM
 7
>Jo, 30
>X Jo
f::=~27
::=]##}#(prin 29)
print (7/6*24)###;alert 2#-[>+<-----]>-.|#(write(if(= 1/5 .2)26 3))"""

编辑: Beatnik被删除,因为可能无法在Beatnik中进行原始性测试。

该代码中包含制表符(由Stack Exchange修改)和结尾的换行符,因此是xxd

00000000: 237c 233f 3135 672c 4020 2020 0920 2020  #|#?15g,@   .   
00000010: 206b 6b6d 4e6d 5361 4965 6f65 3939 2b7b   kkmNmSaIeoe99+{
00000020: 5c23 2f2d 3b6e 4030 6561 0a23 5b39 2140  \#/-;n@0ea.#[9!@
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231  >.>.eeaww#-1@*"1
00000040: 3222 094c 0a23 7b20 090a 2323 230a 2360  2".L.#{ ..###.#`
00000050: 7b0a 3235 0a70 7269 6e74 2834 5e32 202b  {.25.print(4^2 +
00000060: 3729 2f32 0a0a 0a22 2222 0a4a 6f20 6973  7)/2...""".Jo is
00000070: 2068 6572 652e 0a24 276d 6169 6e27 4d6f   here..$'main'Mo
00000080: 4f20 4f4f 4d0a 2037 0a3e 4a6f 2c20 3330  O OOM. 7.>Jo, 30
00000090: 0a3e 5820 4a6f 0a66 3a3a 3d7e 3237 0a3a  .>X Jo.f::=~27.:
000000a0: 3a3d 5d23 237d 2328 7072 696e 2032 3929  :=]##}#(prin 29)
000000b0: 0a70 7269 6e74 2028 372f 362a 3234 2923  .print (7/6*24)#
000000c0: 2323 3b61 6c65 7274 2032 232d 5b3e 2b3c  ##;alert 2#-[>+<
000000d0: 2d2d 2d2d 2d5d 3e2d 2e7c 2328 7772 6974  -----]>-.|#(writ
000000e0: 6528 6966 283d 2031 2f35 202e 3229 3236  e(if(= 1/5 .2)26
000000f0: 2033 2929 2222 220a                       3))""".

或者,您可以从“在线尝试”中复制并粘贴代码链接

这非常糟糕,但是我想摆脱这样一个想法:一旦有了足够的语言,字节数就不再重要了。话虽这么说,我仍然可以轻松地添加一些语言(例如Objeck),但目前它们太长而无法使用。我的语言已经用尽了,所以我现在可能会停在这里。

使用以下命令运行所有程序</dev/null 2>/dev/null(即,空输入,STDERR被压低)。

解释很长,所以这里是执行摘要:

No.  Lang.              Non-esolang?     2D esolang?      BF/BF-deriv?
--------------------------------------------------------------------------
1    COW                                                       ✓
2    CoffeeScript            ✓
3    Common Lisp             ✓
4    Retina
5    Befunge-93                               ✓
6    Python 2                ✓
7    Rail                                     ✓
8    ETA
9    Prelude
10   Gol><>                                   ✓
11   evil
12   Foo                                                       ✓
13   Ruby                    ✓
14   ><>                                      ✓
15   Brian & Chuck                                             ✓
16   Whitespace
17   3var
18   Axo                                      ✓
19   Labyrinth                                ✓
20   Starry
21   Fission                                  ✓
22   Brainfuck                                                 ✓
23   Julia                   ✓
24   Lily                    ✓
25   GolfScript
26   Chicken Scheme          ✓
27   Thue
28   Perl 6                  ✓
29   Picolisp                ✓
30   TRANSCRIPT

1.

COW是Brainfuck派生类,带有其他命令,其中之一是数字输出。任何无效的东西都会被忽略,所以执行的程序仅仅是

MoO OOM

将单元格增加到1,然后将其打印为数字。

2. CoffeeScript(包括解释器)

CoffeeScript看到:

# comments
###
multiline comment
###;alert 2# comment

只是发出警报2。

(是的,如果另一种语言占据这个位置可能会更好,但是我现在懒得重新洗牌了:P)

3. 普通Lisp | 乙二酮

Common Lisp(剪辑)看到:

#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""

1/5是一个有理数,不等于0.2,因此打印3。进行过程"""是语法错误。

请注意,这print似乎在Common Lisp中输出了前一个换行符和尾随空格。但是,幸运的是,它write可以在Common Lisp和Chicken Scheme中使用。

4. 视网膜 | 在线尝试!

引入的限制:从第一行开始的第二行必须是有效的正则表达式。

每对线形成一个替换阶段,用第二行替换第一行的正则表达式匹配项的实例。在中间,我们有一对

“”

它将初始空字符串替换为"""。最后的空行(不是任何对的一部分)被视为匹配阶段,计算正则表达式的匹配数目。中有四个空字符串实例""",即1"2"3"4

5. Befunge-93 | 口译员

Befunge是一种2D语言,相关说明是

# # 15g,@

在第一行,然后5在该25行。#跳过下一指令,15g在位置得到的炭(1, 5)的代码(525线),,输出该炭和@停止。

6. Python 2 | 乙二酮

Python看到:

# comments
25
print(4^2 +7)/2


"""
multiline string
"""

(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6,这是printed。

7. 铁路 | 在线尝试!

Rail是2D语言,其执行从$主要功能的东南开始。因此,代码的相关部分是

$'main'
 7
  o
   J

oJ未来通过从使用TRANSCRIPT线。输出7后,火车撞到了无法识别的J指令,这使程序崩溃。

8. ETA | 在线尝试!

引入的限制: ETA程序之前的字符不应位于etaoinsh

ETA仅识别字母etaoinsh及其大写版本,这意味着代码以

NSaIeoe

n...e根据定界符中的内容推送以7为底的数字,for SaI624或十进制312。o然后输出为char,显然是在取模256之后,给出char 8(代码点56)。e然后尝试除以空堆栈,这将失败。

9. 前奏 | 在线尝试!

引入的限制:()在任何列中最多()只能有一个,一次可以匹配读取一列,不会引起无限循环()

这需要Python解释器进行NUMERIC_OUTPUT = True设置。

前奏是一种语言,其中每行分别执行。许多字符被执行,但重要的是

9!

在第二行中,输出9。()在Prelude中表示一个循环,但是由于#s 的突出(从堆栈弹出),所以在命中循环时堆栈的顶部始终为0,因此它们都不存在正在运行。Prelude的源代码限制()虽然引入了一些多余的空间。

10. Gol> <> | 口译员

这部分(和> <>)的工作方式类似于Martin的答案。相关代码是

#                                      ;n@0ea

Gol> <>是2D语言,可#反映IP,使其向左移动。它回绕,将10、14和0压入堆栈。@然后旋转堆栈,将10移到顶部,将其n输出并;暂停程序。

11. 邪恶 | 在线尝试!

这部分也类似于马丁的答案。

邪恶会忽略除小写字母以外的所有内容。忽略了几个字符,相关的部分是

aeeeaeeaww

其中a递增变量Ae是洗牌的比特恶的编织功能A,和w输出A。因此,我们输出1两次,给出11

但是其余的说明,特别是w最后一行的说明呢?我们可以说有时候混淆代码并祈祷它仍然可以在所有可以正常工作的地方工作是最容易的...

12. Foo | 在线尝试!

Foo在双引号之间输出任何内容,因此相关部分是

"12"

在第二行。但是,由于以后需要双引号,因此我们使用类似于Martin的答案的方法来使Foo出错,即上述方法#-1@。目前尚不清楚为什么这种语言能以一种在空堆和零错误除以的情况下被士兵使用的语言工作,但我很高兴这样做。

13. 红宝石 | 乙二酮

像Python一样,Ruby看到:

# comments
25
print(4^2 +7)/2


"""
multiline string
"""

然而,值得注意的是,多串实际上是三个独立的字符串("""...""")连接在一起。打印行输出(4^2+7) = xor(4,2)+7 = 6+7 = 13,在错误尝试除以nil2 之前输出。

14. > <> | 在线尝试!

该部分与Gol> <>相同,除了@将14向上移动到顶部,然后将其输出。

15. Brian&Chuck | 在线尝试!

Brian&Chuck是具有两个磁带的BF派生词,其中一个磁带的指令指针是另一磁带的内存指针。在没有的情况下```,源代码的前两行用于初始化磁带。

前两行中的相关字符为:

   ?15
#     >.>.

?Brian的胶带在细胞中指出,(过到卡盘传递控制#)为非零值。然后Chuck执行>.>.,在问号后输出两个字符。

16. 空格 | 口译员

分别使用STL空格,制表符和换行符,该程序的开始是:

SSSTSSSSL
TL
STL
L
L

第一行按16(+10000基数2),前一行将其TLST打印为数字。接下来的三行换行暂停了该程序。

但是请注意,该程序特定于解释器。大多数解释器中的其余代码语法错误,因此需要更宽松的解释器,如上面链接的解释器。

17. 3var | 在线尝试!

在第一行中,执行了许多指令,但相关的指令是

kkmmao#/

由于ETA的限制,我们使用k减量B而不是a增加变量B。kk将B减至-2,将mmB平方两次至16,并使用递增至17 a。然后将其输出o

#然后用于将B重置为0,并/导致该程序通过除以0来出错。

18. Axo | 在线尝试!

引入的限制: Axo程序之前没有指令可更改IP的方向

再次,在第一行执行了大量指令,但是相关的指令是

# # 15 ,@            9 9  + {   \

Axo是一种类似于Befunge的2D语言,并且#类似地是一个桥,它跳过下一条指令,但前提是堆栈的顶部为零。15,推送到堆栈,但是用清空了堆栈@99+然后按18,{输出并\停止。

19. 迷宫 | 在线尝试!

迷宫是另一种2D语言,执行的指令是

#|#
 [9!@

#推栈的长度,第一次为0。|是按位或,因此不做任何更改,因为堆栈此时仅具有0,并且#由于唯一的零,第二个堆栈现在压入1。由于1,我们向右转,9将此1转换为1*10+9 = 19,将其!打印并@暂停。

该程序依赖于[当前不是公认的指令的事实,因此被视为隔离墙。

20. 星空 | 在线尝试!

引入的限制:所有都+必须至少有一个前面的空格

如果我们去除无法识别的字符,则代码的相关部分为

,       +.. +

,是输入,但是由于我们从/dev/null那里没有管道,因此将0压入堆栈。+带有n >= 5空格的A 按下n-5,因此下一条指令按下2。..然后以相反的顺序输出这两位。

接下来,我们有一个+带有单个前导空格的重复项。但是,堆栈为空,因此我们会出错。

21. 裂变 | 在线尝试!

与裂变有关的唯一部分是

*"12"L

L产生一个向左移动的原子,"21"打印21并*停止。

22. 脑干 | 在线尝试!

引入的限制:.在第一个之前没有[

这需要一个解释器,该解释器在EOF上给出0,并具有8位单元。相关代码是

,+-[>.>.-+.>,>]-[>+<-----]>-..

初始值-是要偏移+,并且[...]由于单元格为0而不会执行第一个。下面的命令-[>+<-----]>-将单元格设置为的char码2,并..输出两次。

23. 朱莉娅 | 在线尝试!

朱莉娅看到:

# comments
25
print(4^2 +7)/2

输出的是4^2+7 = pow(4,2)+7 = 16+7 = 23,程序尝试除以nothing2时出错。请注意,Julia似乎并不介意其余的代码仍然会引起语法错误。

24. 百合 | 口译员

莉莉看到:

# comment
#[
multiline comment
]## comment
print (7/6*24)# comment

7/6*24 = 1*24 = 24 打印。

25. GolfScript | 在线尝试!

GolfScript看到:

# comments
25
print(

GolfScript基于堆栈,因此将25推入堆栈,然后弹出并用打印print(然后尝试减少堆栈上的隐式空字符串,这将失败并导致程序出错。

26. 养鸡计划 | 乙二酮

Chicken Scheme #| ... |#与Common Lisp 具有相同的多行注释语法。但是,在

(write(if(= 1/5 .2)26 3))

1/5是一个浮子,其等于0.2,所以26代替输出。

27. 图厄 | 在线尝试!

Thue是一种基于字符串重写的语言。第一个相关部分是

f::=~27
::=

定义了替换,f -> 27然后用表示替换的结束::=。然后将lone fin if替换27为输出。

28. Perl 6 | 乙二酮

Perl 6具有新的注释语法,即#`(some bracket)从多行注释一直到匹配的括号。因此,Perl 6看到:

# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment

打印7/6*24 = 28

29. Picolisp | 乙二酮

Picolisp看到:

# comment
#{
multiline comment
}#(prin 29)

打印29。此行随后导致语法错误。

30. 笔录 | 在线尝试!

TRANSCRIPT是一个以文字冒险为蓝本的主题世界。无法识别的行将被忽略(这使您可以在实际的代码说明中添加额外的故事/风味文字),因此相关行为:

Jo is here.
>Jo, 30
>X Jo

第一行Jo使用两个字母的名称声明一个字符串变量,因为一个字母的名称似乎失败了。第二行将此字符串设置为"30",由X第三行中的(“检查”)输出。


12
Daaaaaaaaaang ...
AdmBorkBork '16

9
我怀疑这可能是这里所有问题中最低的非零得分。
Morgan Thrapp '16

这难以置信。我很敬畏
Nic Hartley

2
*正面,对于带奖金的简短答案有一些负面分数。
CalculatorFeline

未来的专业提示:如果将代码pre括在标记中而不是使用Markdown样式的代码块,则不会混淆您的标签。
雅各布

148

15种语言,68 66 65个字节/ 15 ^ 3 = 0.019 ...

视网膜星空前奏 ETA Axo迷宫六角形 Foo Brian&Chuck Gol> <>邪恶空白裂变 > <> GolfScript

经过大量的重写之后,我设法适应了另外四种语言。该代码包含空白的一些选项卡。由于Stack Exchange将它们转换为空格,因此我在\t下面表示了它们:

#I5aeeNTH{\?      \t\t + +3;n@"8"ea9
15}7'`--~!@<"31"LSOe.\t
 \teaww`

我想我已经完成了添加语言的操作(尽管仅添加一种语言可能会节省一些字节)。我不知道它是否可以打高尔夫球……15种语言的65个字节与11种语言的32个字节相比是一个很大的跳跃,现在我至少有一个无用的字符使Foo正常工作。

视网膜版画 1

在线尝试。

幸运的是,第一行是有效的正则表达式。但是,该正则表达式显然与空输入不匹配,因此第一阶段(由前两行组成)不执行任何操作。

第三行是独立的,因此将其视为Match阶段,默认情况下,该阶段会计算匹配数。但是,`是一个分隔符,告诉视网膜它前面的部分是配置字符串(它不知道那里提供的任何选项),而后面的部分是正则表达式。因此正则表达式为空,Retina恰好找到了一个匹配项。

星空印花 2

在线尝试。

星空忽略除空格和以外的所有内容+*,'`.。自最后一个字符以来,每个命令都是这些字符之一,并带有空格。因此,让我们删除所有无关的代码:

       + +'`. `

七个空格,然后按+一个2。一个空格后跟一个+副本。'是有条件的跳跃。它弹出堆栈的顶部,这是真实的(正),因此它跳到相应的标签(其中标签由表示`,“相应”表示“具有相同的前导空格”)是第一个`.它前面没有空格,然后将堆栈顶部打印为数字。

前奏版画 3

在线尝试。

假设使用数字输出的Python解释器。让我们删除所有无操作:

# 5        ?         + +3    8   9
15 7  -- !   31

第一个声音会做很多事情,但没关系,因为没有!任何结果可以打印。第二个声音按a 1,然后按a 5,然后按a 7。我们将最后两个值之差得到-2,然后从中减去1得到3!打印它。第三声音只有无操作。

预计到达时间 4

在线尝试。

ETA会忽略除字符以外的所有内容ETAOINSH(无论如何)。因此,ETA看到的代码是:

IaeeNTHneaSOeea

I尝试读取输入但无法读取,因此将其推送-1a推送当前行号加1,即2edivmod,它将替换为0and 1(或-1,我实际上不知道,但这没关系)。下一个e用替换它们0

现在是有趣的部分。NTHne是一个以7为底的数字文字。Ne只是分隔符,而三个数字是THN。那就是54(哪里T是digit 1H0n5)。再次a推动2S减去它,得到52O输出为字符(4)。现在e再次尝试divmod,但是堆栈中包含两个零,因此程序会因错误终止(但这样做不会污染STDOUT)。

Axo版画 5

在线尝试。

这种语言几乎完全由一人负责。我不能}在第一行上使用它,因为它会阻止在Axo中进行输入(有关我所谈论的内容,请参阅修订历史记录)。对于Axo,仅这部分代码是相关的:

#I5aeeNTH{\

幸运的是,Axo 0在其堆栈的底部还具有隐式s,因为它会#弹出堆栈的顶部(以检查是否应跳过下一条指令)。这些字母都是无人操作。然后5按一下5{打印出来,\终止程序。真的很简单。

迷宫版画 6

在线尝试。

我将代码截断了一点,因为从未达到右半部分,并且我也使用t来代替\t,以便各列正确对齐:

#I5aeeNTH{\
15}7'`--~!@
 teaww`

现在,字母,空格和制表符是迷宫中的墙,因此可访问的代码实际上如下所示:

# 5      {\
15}7'`--~!@
      `

指令指针将自动遵循该路径。#推动主堆栈的深度(0)并15使其变成一个15}将其移至辅助堆栈,我们将不再使用它。这样可以方便地使栈顶为零,从而使IP不会左移到上57将零变成a 7'是无操作。该`是一元的否定,所以我们得到-7。现在从使它隐式的下面-减去。这次,IP确实会右移到,这是一元否定的,因此我们再次得到了。IP碰到死胡同。在像以前一样做同样的事情,所以我们得到-707`7-7再一次。由于栈顶为正,因此IP向右转。还有另一个再次-给予-7。然后~是按位非,它给出6!打印它。那是这样做的正确时机,因为现在堆栈再次为空,因此IP不会左移到上,{而是继续直接进入@终止程序的。

六角纹 7

在线尝试。

展开的代码如下所示:

     # I 5 a e
    e N T H { \
   ? + + 3 ; n @
  " 8 " e a 9 1 5
 } 7 ' - - ~ ! @ <
  " 3 1 " L S O e
   . e a w w . .
    . . . . . .
     . . . . .

通常,这将是一个可怕的Hexagony程序,但是实际使用的字符并不太多。事实上,他们是几乎相同的迷宫中使用,我想我区分的方式56是相当不错的。:)

第一行基本上可以忽略。#通常会切换到其他IP,但当前的内存边为0,因此不是。字母只是设置一个固定的内存值,但我们将不使用它。在第一行结束之后,控制流在中间行继续(从},开始,向右)。在}移动到另一个存储器边缘。7将该边缘设置为7'移回我们来自的地方。-从未7使用的内存边沿(0)中减去我们刚刚设置的内存边沿,因此得到-7。下-一个再次执行相同的操作,因此是空操作。到目前为止,与迷宫非常相似(除了内存布局)。但现在~在六角形中不是按位非,而是一元否定。所以这给7代替6!@,就像在迷宫中打印值并终止程序一样。

脚印 8

在线尝试。

众所周知,自从《The Programming Language Quiz》以来,即使大多数代码都是随机的字符杂乱的字符,在Foo中打印内容也非常简单。除了"8"打印的字符外,没有其他字符会影响输出8。好了,"31"后面有,但是Foo在第一行的结尾处以错误终止。我不确定为什么会发生这种情况,但它要求3顶行(或其他任何数字)没有在其他任何地方使用。

Brian&Chuck版画 9

在线尝试。

让我们再做一次,删除第三行(从未解析过),并用空格替换所有不相关的字符(例如,无操作或未读取的单元格):

         { ?         + +         9
  }   --   <        .

提醒一下,每一行都像Brainfuck一样,其磁带是另一个程序的源代码。控制流从第一行开始(称为Brian)。

{磁头移动一直到左侧(在那里它已经是),并?把控制流过查克(第二行)。在那里,}将磁带头向右移动,直到找到零单元为止。直到程序结束,这种情况才会发生,因此磁带头在之后的一个单元格结束9-减少该单元格,但这无关紧要。<将磁带头移到9.打印。Chuck的程序用完并终止。

Gol> <>打印 10

在这里测试。

#是一个镜像,因此IP立即跳到第一行的末尾(并向左移动)。在9可以忽略不计。a10e推压14"8"推压的字符代码8@旋转三甲堆栈元素(拉起10),使得n打印10;终止程序。

感谢Sp3000建议使用@代替!(节省了一个字节)。

邪恶的印记 11

感谢Sp3000向我发送了一些蛮力命令列表以生成个位数的命令。

在线尝试。

除小写字母外,evil会忽略所有内容,因此代码如下所示:

aeeneaeeaww

此外,它n会影响某些我们不关心的状态,因此我们也忽略它。现在a增加寄存器(从处开始0),这e是邪恶的魔术“编织”操作,它以特定方式置换位。aeeeaeea碰巧产生的值49是的字符代码1ww打印两次。

空白打印 12

在线尝试。

好的,我们知道Whitespace只能读取空格,制表符和换行符,因此让我们编写Whitespace看到的代码STL

SSSSSSTTSSLTLST

这是两个命令:

SSSSSSTTSSL
TLST

第一个按数字12。具体来说,SS开始一个数字文字。下一个S是符号位(正)。那么直到的所有内容L都是数字的二进制表示形式。对于Starry,我们需要大量的前导零,但它们不会影响该数字。那么TTSSs是12二进制的。有趣的事实:如果我添加了第16种语言,则可以在此处保存一个字节,因为Starry可以S在的二进制表示中使用这四种语言16。我怀疑我会...

TLST刚刚打印堆栈多项顶部。(TL将该命令标记为I / O命令,并且ST正在打印数字。)

裂变版画 13

在线尝试。

Fission仅看到代码的以下部分:

           <"31"L

L从左移原子开始控制流。"切换打印模式,以便31仅打印13。然后,将原子捕获到的楔形中<,从而终止程序。

> <>打印 14

在这里测试。

区分> <>和Gol> <>并不是我想的那么容易,因为对于同时存在的命令和仅存在于Gol> < >导致> <>崩溃。但是,@在> <>中以另一种方式旋转,以使其向下推7而不是向上拉10,然后14打印获取而不是10

GolfScript打印 15

在线尝试。

这是最简单的:#注释掉第一行。然后15推入自身,这}是一个“超级注释”,它会忽略程序的其余部分。因此15,将在程序末尾打印。


34
这真是令人印象深刻!
sweerpotato

1
@YassinHajaj谢谢,纠正了。
马丁·恩德

2
Niiice。15种语言的出色表现!
ev3commander's

1
@SnoringFrog好,你去。
马丁·恩德

1
@Eumel谢谢,但是赏金专门针对其描述中列出的“正常”语言,因此赏金应归功于这种答案(例如Sp3000的非常好的解决方案)。无论如何,我认为我得到了足够的代表。;)
Martin Ender 2015年

42

Python 1.x,2.x和3.x,32字节/ 3 ^ 3 = 1.1851 ...

import sys
print(sys.version[0])

打印版本的第一个数字,1在Python 1.x,2Python 2.x和3Python 3.x中。

到我们获得Python 9.x时,我的成绩将是辉煌的0.04389

:〜)!


10
通过聊天:是的,这既便宜又有效=)这就是为什么只有主要版本才被认为足够独特的部分原因。我不知道有多少个Python版本,但是使用类似这样的方法,您可能会获得相当低的分数……这是我真正了解正在发生的事情的少数解决方案之一,因此我向+1;- )
Stewie Griffin

6
在python 10.x中(如果存在)不会打印,1因为它是字符串“ 10.whatever”的第一个字符?
ev3commander 2015年

1
@ ev3commander但是,未指定此提交在python10中产生正确的输出。
Tyzoid 2015年

固定!正在使用面向未来的版本,但是Python 1.x并不像其他版本那样易于使用:〜)!
sweerpotato

1
我需要做的就是创建一种具有三个主要版本的语言。在这三个主要版本中,运行空文件时将返回主要版本号。结果将是0/3 ^ 3 = 0完美。
Braden Steffaniak 2015年

32

3种语言,2字节/ 27 = 0.074

1P

好吧,它至少击败了一半的提交:P

1. GolfScript

GolfScript忽略P,仅输出1. 在线尝试

2. 标准杆

P是2的幂,所以1P = 2^1 = 2在线尝试

3. 认真

P给出第n个素数,索引为零。我们得到3,因为那是第二个素数。在线尝试


笔记

我最初的目标是在1个字节内找到有效答案。我的第一个尝试是\x12Bubblegumgs2中工作,但挑战至少需要三种语言。\x13如果有一种语言可以输出1。

放弃一个1字节的答案,我搬到了两个字节。3u是一个很接近的调用,在Japt中输出1,在GolfScript中输出3,在Seriously中输出4,但是很难找到一种输出2的语言来填补空白。

所有这些使我花了太长时间:/


20

6种语言-44字节/ 6 ^ 3 = 0.204 ...

感谢SnoringFrog节省了10个字节!

适用于:

  • Befunge
  • 腐霉菌
  • 脑干
  • 六角形
  • 空格
  • AniRad v0.2

2# "1",@"-[----->+<]>.*@@@!4<SSTST
T
ST
 >6=

注意:在线尝试之前,请确保将S替换为空格,将T替换为制表符,或将以下十六进制转储转换为ASCII

32 23 20 22 31 22 2c 40 22 2d 5b 2d 2d 2d 2d 2d 3e 2b 3c 5d 3e 2e 2a 40 40 40 21 34 3c 20 20 09 20 09 0d 0a 09 0d 0a 20 09 0d 0a 20 3e 36 3d

我将尝试使用更多的编程语言:)

Befunge(打印1):

在线尝试

2# "1",@"-[----->+<]>.*@@@!4<
2                             # This puts 2 onto the stack
 #                            # Skips the next op (the space)
   "1"                        # Sets the ASCII value of 1 onto the stack
      ,                       # Pop the last item (1)
       @                      # Terminate program

Pyth(打印2):

在线尝试

2# "1",@"-[----->+<]>.*@@@!4<
2                             # Prints 2
 #                            # Infinite while loop until an error occurs
   "1"                        # String
      ,@                      # This gives the error and terminates the program

Brainfuck(打印3):

在线尝试

2# "1",@"-[----->+<]>.*@@@!4<
2# "1",@"                     # Since these are not brainfuck ops, these will be ignored
         -[----->+<]>         # Puts "3" on the stack
                     .        # Prints the last item (3)     

六角形(打印4):

在线尝试

2# "1",@"-[----->+<]>.*@@@!4<   

更具可读性的版本:

   2 # " 1       # The steps:
  " , @ " -      # 1 (2) - Hexagony starts at the top-left of the hexagon
 [ - - - - -     #       - This immediately puts 2 onto the stack
> + < ] > . *    # 2 (#) - Since the stack is 2, this makes the 2nd pointer the 
 @ @ @ ! 4 <     #       - new current pointer
  > 6 = . .      # 3 (*) - The position of the 2nd pointer is in the left-most
   . . . .       #       - position. This sets the stack to the product
                         - of the two neighbours which is zero
                 # 4 (<) - Changes the pointer direction to west
                 # 5 (4) - Sets the stack to 4
                 # 6 (!) - Outputs the decimal 4
                 # 7 (@) - Terminates the program

空格(打印5):

在线尝试

由于除了空格和制表符以外的其他字符都被忽略,因此我们剩下以下内容:

SSTST                 # This pushes 5 onto the stack
T                     # 
ST                    # This prints the decimal

AniRad版本0.2(打印6):

这在某种程度上适用于0.2版,但对于0.4版却给出了错误。我不知道为什么。您可以在此处找到0.2版。为了运行此程序,您可以将解释程序的代码复制并粘贴到repl.it并运行它。之后,您只需要将程序粘贴到STDIN并运行即可。

2# "1",@"-[----->+<]>.*@@@!4<      # (#)  Starts at the hashtag (starting point)
                                   #      Direction is down
                                   # (>)  When the pointer gets to the '>', it changes
 >6=                               #      its direction
                                   # (6) Puts 6 onto the stack 
                                   # (=) Pushes the result and terminates

1
我认为应该走更多的语言...立方分母真的很慷慨,因此一旦您拥有5种或6种语言,要击败我的分数就不难了。
马丁·恩德

@MartinBüttner,是的,尽管我看不到如何添加新语言
Adnan

2
@Martin是的,它很慷慨。三次方分母的目的是强烈鼓励更多语言。我认为50个字节中的6种语言应该与30个字节中的5种语言相同。:-)您使用的语言越多,肯定会越难。
Stewie Griffin 2015年

您的空白代码可能会有所减少(我认为它不会影响您的任何其他语言。(使用L作为换行符),而不是SSSSSSSSSSTTSTSTLTLSS现在可以使用的代码SSSTSTLTLST。这会将原义5压入堆栈,然后打印为整数
SnoringFrog

@SnoringFrog谢谢!我已经对其进行了编辑
Adnan 2015年

14

6 7种语言,32 37个字节,得分0.148 ... 37/7 3 ≈0.107872 ...

#7+!"@\"6.@;n5
print(4--int(-3/2)#"
)

脑力激荡

+增加当前单元格,!打印为整数,@退出。#并且"是NOP。

Python 2

第一行是评论。使用整数除法,计算4 - -int(-3 / 2) = 4 - -int(-2) = 4 - -(-2) = 4 - 2 = 2并打印结果。

Python 3

与以前相同,但具有浮点除法。4 - -int(-3 / 2) = 4 - -int(-1.5) = 4 - -(-1) = 4 - 1 = 3

a

--开始评论,#第一行是评论,因此基本上是print(4)

> <>

#反映IP,5按5,n打印号码并;退出。

Befunge

#跳过+!从逻辑上取反堆栈的顶部,"@\"推入字符串@\6推入6,.打印一个数字并@退出。

腐霉菌

#启动无限循环,消除所有错误。7打印7,然后跟随+!"string"),这基本上会导致没有两个操作数的错误+,从而终止程序。


13

JavaC ++ C,363/27 = 13.4 ....

Java打印1,C ++打印2,C打印3。这里没有中断任何记录(因为Java),但是我真的很喜欢用我发现的这些语言制作多语种的巧妙,滥用方式。

//\u000a/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*\u002a/
import static java.lang.System.out;
public class P{//*/
/*\u002a/public static void//*/
main(/*\u002a/String[] args//*/
){//\u000a/*
out.print=p;
//\u002a/
out.print(1);}
/*\u002a/}//*/

真是一团糟。这是其工作方式的细分。Java编译器将Unicode文字(\u000a,也称为换行符,以及\u002a,称为*)扩展为它们的实际字符。因此,这是Java编译器看到的内容:

//
/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/**/
import static java.lang.System.out;
public class P{//*/
/**/public static void//*/
main(/**/String[] args//*/
){//
/*
out.print=p;
//*/
out.print(1);}
/**/}//*/

开头的所有内容都将被忽略,因为它们都包含在多行注释(/* ... */)中。稍后,我们看到混合使用单行和多行注释可以使我们精确地控制每种语言中注释掉的部分。在main方法中,我们开始进行多行注释,然后使用//*/。通常,这将是单行注释,但是由于我们处于多行注释中,因此//它不会执行任何操作,因此可以将*/其关闭。

这是等效的Java代码,但删除了注释:

import static java.lang.System.out;
public class P{
public static void
main(String[] args
){
out.print(1);}
}

这是C / C ++编译器看到的内容(我删除了Unicode文字,因为它们没有被编译器扩展,因此不执行任何操作):

///*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*/
import static java.lang.System.out;
public class P{//*/
/*/public static void//*/
main(/*/String[] args//*/
){//\/*
out.print=p;
///
out.print(1);}
/*/}//*/

在这里,单行注释在开始时会覆盖多行注释定界符,因此所有#defines和#includeget都要进行预处理。接下来,使用多行注释来注释掉Java的boiletplate代码。这是等效的代码,删除了注释:

#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
main(
){
out.print=p;
out.print(1);}

利用标准C / C ++多语言技巧(#ifdef __cplusplus)将令牌定义o"2""3",这取决于是编译代码的C ++还是C编译器。接下来,我们使用新定义的令牌定义一个函数p,该函数采用一个(忽略的)int参数并调用。和往常一样,由于我们不在严格模式下,返回值被忽略了。接下来,我们定义一个具有单个成员的,其签名与匹配的函数指针,并构造一个名为的实例。在main方法(我们离开关照常),地址被分配给(因此调用电话),它被调用。printfostructpoutintpout.printout.printp

如果这些语言未包含C ++,则可以删除所有预处理器代码,并将其定义pint p(int a){puts("2");}。不幸的是,C ++需要一个#includeI / O。如果不包括C,则可以删除p#ifdef宏的定义,并直接在中定义成员函数,struct而不需要函数指针。不幸的是,C不支持成员函数。


12

4种语言,28个字节/ 64 = 0.4375

print((0 and 3^1or 1/2>0)+1)

1. Python 2

0是虚假的并且/是整数除法,所以

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0 > 0) + 1 = False + 1 = 1

2. Perl(也是Python 3)

0是虚假的并且/是浮点除法的,所以

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0.5 > 0) + 1 = 1 + 1 = 2

3.红宝石

0是真实的,^是按位异或,所以

(0 and 3^1 or 1/2 > 0) + 1 = xor(3,1) + 1 = 2 + 1 = 3

4.卢阿

0是真实的,^是幂运算,所以

(0 and 3^1 or 1/2 > 0) + 1 = pow(3,1) + 1 = 3 + 1 = 4

请注意,Lua和Ruby无法将布尔值视为整数,因此无法将布尔值组合在一起。不幸的是0and在Lua中不起作用,所以我们不能在那里保存字节。


先前的17字节版本可显示1(Lua),2(Ruby),3(Python / Perl):

print(2^(0 or 1))

感谢@xnor为该版本提供-3个字节,使其更加整洁:)


2^(0 or 1)工作吗?
xnor

@xnor嗯,是的,谢谢:)
Sp3000

8

BFSRS> <> funge93thon123,73/343≈0.212827 ...

Brainfuck,认真地,> <>,​​Befunge-93,Python 1,Python 2,Python 3

# 4['.]@kX21z-[>+<-----]>--.<;n3
import sys;print(3+int(sys.version[0]))

包含不可打印的内容,十六进制转储(可通过反转xxd -ps -r):

2320345b272e5d406b5832317a7f2d5b3e2b3c2d2d2d2d2d5d3e2d2d2e3c
3b6e330a696d706f7274207379733b7072696e7428332b696e7428737973
2e76657273696f6e5b305d2929

随着时间的推移,我将添加更多的语言(可能还有字节)。标头中的语言按打印的顺序列出。假定8位包装单元和一条磁带不会抱怨Brainfuck的初始位置(包装或无限)。

脑干:

[.]   initial value of first cell is 0, so loop is skipped
-[>+<-----]>--  push 49 (ASCII ordinal of 1)
.     print "1"
<     move to blank cell
[0]   skip loop because cell is 0
      everything else is ignored

认真地

# 4['.]@  does some stuff we don't care about
kX        pop entire stack, push as list, discard (essentially the same as é, but is ASCII so we can use Python)
2         push 2
1z        pop 1 item from stack and print (used instead of . so Brainfuck doesn't print here; same as ü in this scenario, but is ASCII so we can use Python)
0x7f      terminate program
          everything else is ignored

><>

#    mirror, reverse direction
3n;  push 3, print "3", end (reversed because IP is scanning RTL at this point)
     everything else is ignored

Befunge-93:

#     jump over the space
4['.] push 4, print 4 (brackets and ' do nothing)
@     end program
      everything else is ignored

Python 1(感谢泥dy):

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+1=5

Python 2

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+2=6

Python 3

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+3=7

Python 1也可以。请参阅codegolf.stackexchange.com/a/65652/32686。不添加任何字符(但更改34
蓝色

8

14种语言,73个字节,分数=(73/14 ^ 3)= 0.02660349854

#Y2(3`5n~thneo e        ;n@0d c
#   -[>+<"9"L-----]>+.
14  
print(int(15/2))+3

我可以添加更多的lang,但我想我会在这里添加我的内容。

1. Brainbool ; 在线尝试!

相关代码:

    [>+<         ]>+.

               + 

这实际上只是+.+输出1。

2. 欢乐在这里尝试!

所述(炭停止解释源代码,所以relavent代码是:

#Y2

这等效于(在JavaScript中)

var Y = []; toHex(Y); alert(2);

哪个输出2。

3.元素;在线尝试!

相关代码:

    3`

这将捕获3并打印它。

4. 脑干在线尝试!

相关代码为:

-[>+<    -----]>+.

  -    -      + 

这是生成4的字符代码并输出它的标准方法,以及它后面的其他内容。

5. R;在这里尝试!

~ 终止程序,因此这里的相关代码是:

#Y2(3`5n~

#重新定义Y为TOS,在这种情况下为02推2; (将堆栈旋转N次,从堆栈中弹出N;3`推-3; 最后是5nprints 5

6. ETA;在线尝试!

ETA仅读取字母E,T,A,O,I,N,S,H,因此仅执行的代码是这样的:

       n thneo e         n     


  int int          

超级相关的代码:

       n thneo

或等效地:nthne on...e是7进制的文字,并且thn是54的7进制数字。o输出此字符。提交错误,但我不知道为什么。

7. Python 3

所见:

# comment
# comment
14
print(int(15/2))+3

15/2/浮点除法的结果为7.5 。int(...)将数字设置为int,然后将其打印出来。+3遇到错误时程序出错。

8.朱莉娅

朱莉娅看到:

# comment
# comment
14
print(int(15/2))+3

朱莉娅不舍弃15/2,而是四舍五入,得到8。它将打印出来,然后在遇到+3时出错。

9.裂变;在线尝试!

相关代码:

        <"9"L         

我是从Martin的Fission部分获得这个想法(更像是偷了它)。L开始朝左的事物,捕捉9并结束于<

10.空格;在这里尝试!

相关代码,将空格转换为S和制表符T

SSSTSTS
T
ST

它将10压入堆栈并输出为数字(T\nST)。

11. Python 2

Python 2看到了这一点:

# comment
# comment
14
print(int(15/2))+3

(int(15/2))+3 被评估为11,并打印出来。

12. Gol> <>; 在这里尝试!

相关代码:

#                      ;n@0d c

这使用了马丁答案中使用的技巧,即@在> <>和Gol> <> 中旋转不同的方向。#镜,c推12,d推压13,0推0,并且@使c向堆栈的顶部,然后被outted并印有;n

13.> <>; 在线尝试!

相关代码:

#                      ;n@0d c

再次使用可以@在> <>和Gol> <> 中旋转不同的方向。#镜,c推12,d推压13,0推0,并且@使d向堆栈的顶部,然后被outted并印有;n

14. Golfscript;在线尝试!

所见:

# comment
# comment
    14
print(-int(-15/2))+3

它会推14,推print和出错。受Sp3000的启发而被盗


7

Subskin,Brainfuck和Fob 27字节/ 3 ^ 3 = 1

0#>&$3#<>$-[----->+<]>-.
31

皮下

0
31

我们将指令指针(在这里无关紧要)设置为0,将输出寄存器设置为31。如果输出寄存器的内容为>= 0,则将包含的值输出为char。所有其他代码将被忽略。

脑干

-[----->+<]>-.

3在寄存器,与一次递减值-,最后用输出.

离岸价

#>&$3#<>$

这有点棘手,因为Brainfuck还阅读了Fob中的<>指令。我们使用进入执行模式,#然后将Brainfuck的指针加1,这使我们以后更容易使用。我们没有什么要执行的,因此什么也没有执行。

我们进入与蓄能器模式$,扔在一个3,再次进入执行模式,推动累加器的内容到堆栈<,最后我们输出与内容>

为了防止Brainfuck与程序发生冲突,我们使用再次进入累积模式$


7

7种语言,55/7 ^ 3≈0.16035

在PowerShell v1,v2,v3,v4和v5,Foo和Pyth中运行

#7.q"6""
$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]

数字1-5使用类似的逻辑表示sweerpotato的答案。在$PSVersionTable特殊的变量是在PowerShell中V2介绍,并包含一个完整的构建列表,修订,等这里的可变的输出示例:

PS C:\Tools\Scripts> $PSVersionTable

Name                           Value                                                                                                                           
----                           -----                               
PSVersion                      4.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.34209
BuildVersion                   6.3.9600.17400
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion      2.2

在此代码中,我们首先将其存储到其中$p,以使代码长度更短。然后,我们通过利用变量作为两个项目数组的索引来检查其是否存在:

  • 如果该变量不存在,PowerShell将动态创建并分配它$NULL!其值为$TRUE1,它对应于数组中输出第二个元素的元素1
  • 如果确实存在该变量(如v2 +中的情况),则!变量的结果为$FALSE0,索引到第一个元素,该元素输出版本号。

使用Foo for 6,我们可以利用#PowerShell中的注释,因此在PS环境中执行该注释时将被忽略。但是,Foo会很乐意吐出这个数字6,然后继续执行该程序的其余部分,但不会执行任何操作。

将Pyth用于7,我们返回7,然后立即使用退出.q,因此以开头的无限while-true循环#无关紧要。由于我们还有一些隐式打印的内容。感谢@ FryAmTheEggman的添加。

编辑-多亏了毛里斯(Mauris), 打了几个字节编辑-多亏了Sp3000,澄清了Pyth的解释


怎么$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]样 这在我的Powershell上有效,但可能不适用于所有以前的版本。
林恩

7

7种语言,287/7 ^ 3 = 0.836

可能是最低的分数,无论如何,我都喜欢C语言的3个版本。

添加了无聊的Python解决方案,至少有资格获得“ 3种独特”语言的赏金。

通过滥用C三字母组合来添加Java,以实现不同的注释解释。

适用于:

  • Python 1

  • Python 2

  • Python 3

  • C89

  • C99

  • C ++

  • 爪哇

高尔夫球版:

/*
*??/
/
#include <stdio.h>
#ifndef __cplusplus
#define true 8/*
import sys
print(sys.version[0])
'''
#*??/
/
#endif
int main(){int a=(true>1)?-6:3;printf("%d",(true//*
+a
//**??/
/+2));}
#define a \
'''
/**\u002f
public class p{public static void main(){System.out.println("7");}}
/**/

取消高尔夫:

/*
*??/
/

#include <stdio.h>

#ifndef __cplusplus
#define true 8/*

import sys
print(sys.version[0])
'''
#*??/
/
#endif 

int main()
{
    int a = (true > 1) ? -6 : 3;
    printf ("%d", (true//*
    +a
    //**??/
/
    +2));
}
#define a \
'''

/**\u002f
public class p
{
    public static void main()
    {
        System.out.println("7");
    }
}
/**/

好吧,这可能有点奇怪,我希望我的英语水平足以解释普通水平。

首先,我将解释我用来封装每种语言结构的各种注释。

因此,让我们采取第一个步骤:

/*
*??/
/

对于Java,这仅仅是多行注释的开始。但是...在C99 / 89 / ++中,其计算结果为

/*
*/

由于??/\C语言\中的三部曲,字符在某种程度上是一致的,甚至在命令功能上消耗了换行符。这将导致an的结果\n只是“显示”,而不是蜂鸣的换行符。也就是说,给定此字节数组代表第一个块:[ /] [ ] [ *] [ \n] [ *] [ ?] [ ?] [ /] [ \n] [ /]将在三字组合运算后:[ /] [ *] [ \n] [ *] [ \] [ \n] [ /] \触发器具有一致的功能并“消费”,\n因此C lang评估字节中的剩余字节和终结字节为:[ /] [ *] [ \n] [ *] [ /]

但是关于这一切,Java对此一无所知,并将其后的所有内容视为注释,直到此技巧被恢复为止。

(未完待续!)


7

4种语言(Befunge-93,Microscript II,Microscript和Foo),得分7/64 = 0.109

"4"1.@2

Befunge:按4,按1,打印1,然后终止。

Microscript II:产生字符串“ 4”,丢弃它,取一的平方根,丢弃它,最后将x设置为2。然后隐式打印。

Microscript:将52推入堆栈(该堆栈实际上将不会用于程序的其余部分),将寄存器(最初为零)加1,然后将寄存器加2。然后将其隐式打印。

Foo:打印字符串“ 4”,然后按2


6

Python 1 | 2 | 3,27个字节/ 27 = 1

print(len("\xabc")+(1/2>0))

@sweerpotato对版本号的使用使我想知道是否有可能用更少的语言来区分Python。这是我找到的最好的。

说明

为了将Python 3与早期版本区分开来,我们使用了标准整数除法与浮点除法的技巧。从Python 2.3 (1/2>0) == (0>0)之前版本或False从Python 2.3开始返回0 ,并为Python 3 (1/2>0) == (0.5>0)返回True

为了将Python 1与其他Python区别开来,我们采用字符串的长度"\xabc",它在Python 1中为1,在Python 2之后为2。为什么?因为

现在,字符串文字中的\ x转义正好需要2个十六进制数字。以前,它将消耗'x'之后的所有十六进制数字,并占用结果的最低8位,因此\ x123456等效于\ x56。

(从 Python 2.0的新功能


6

Python 3,Ruby,Perl,C,C ++,Objective-C 202字节/ 6 ^ 3 = 0.935 ...

实际上,这很有趣,而且很多人都在玩布尔值。

通过将代码复制并粘贴到解释器中,可以在以下站点上找到所有版本的代码。

#include <stdio.h> /*
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1
"""""
*/
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}/*
"""
#*/

Python 3,打印 1

诀窍如下:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

这将打印 1

红宝石,版画 2

Ruby的解释代码为:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

所以这印 2

Perl,打印 3

Perl的解释代码为:

print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1

首先,该__DATA__令牌告诉Perl编译器编译已完成。之后的所有内容都将被忽略。

print ((("0"+"0"==0)and 3) or (0and 2or 1));

和印刷品 3

C,版画 4

解释后的代码与其他代码完全不同:

#include <stdio.h>
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}

这将简单地打印字符 4

C ++,印刷品 5

与C代码相同

这将打印字符 5

Objective-C,印刷品 6

与C代码相同

这将打印字符6


5

5种语言,18字节/ 5 ^ 3 = 0.144

BrainboolMathematicaFoo> <>Befunge-93中运行

4!<n;+Print@2"3".5

脑袋

Brainbool类似于Brainfuck,但它仅对位进行操作,并且其输入和输出仅由0和组成1

4!<n;+Print@2"3".5
  <                   move the pointer to the left
     +                logic not
                .     print the current cell

Mathematica

在Mathematica中,一切都是表达,并且具有价值。Print@2打印2并返回符号Null。此后,代码执行一些符号计算,但不输出任何内容。

oo

"3" 打印3.我不知道其他部分做什么。

> <>

4!<n;+Print@2"3".5
4                     push 4
 !                    skip the next command
   n                  pop and print it as a number
    ;                 end the program

Befunge

4!<n;+Print@2"3".5
4                     push 4
 !                    logical not
  <                   makes the program counter travel to the right
 !                    logical not
4                     push 4
                 5    push 5
                .     pop and print it as a number
             "3"      push the string "3"
            2         push 2
           @          end the program

12种语言,35个字节/ 12 ^ 3 = 0.0202546 ...

使用sweerpotato的技巧,便宜却强大。

BrainboolMathematica 2.0、3.0、4.0、5.0、6.0、7.0、8.0、9.0 和10.0Foo> <>中运行

cn;+"11".Print@Floor@$VersionNumber


5

6种语言,38/6 ^ 3 =0.17592̅5̅9̅

空格,Brainfuck,红宝石,迷宫,Foo,认真

传说:

£: 标签

: 空间

§:0x7f

puts•2;#4!@•-[>+<-----]>6.§"5"•£    
£
•£

它包含不可打印的字符,因此,这是十六进制转储:

7075747320323b23342140202d5b3e2b3c2d2d2d2d2d5d3e362e7f22352220090a090a20090a

说明:

空格

在线尝试。(注意:我的程序省略了最后三个换行符以终止程序,我在Whitelips上编写/测试了此代码并产生了正确的输出,但是在“在线尝试”中却没有,因此链接的程序中添加了这两个字符。据我所知,一些解释器允许您这样做,其他解释器则陷入无限循环而没有显式终止)

(忽略被忽略的字符)

spacespacespacetabenter:将1推入堆栈

tabenterspacetab:输出栈顶

红宝石

不需要解释。打印2,将该行的其余部分(ergo,brainfuck程序)视为注释,将文件的其余部分视为空。

脑干

在线尝试。

需要支持下溢的解释器。将第一个单元下溢到255,然后将其用于循环计数器以生成51,这是3的ascii代码。

迷宫

在线尝试。

(为了清楚起见,省略了最后两行,因为它们从未到达过)

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•                            skipped
     2                           push 2 onto stack
      ;                          pop 2 from stack
       #                         push current stack depth (0) to stack
        4                        push 4 to stack
         !                       print top of stack as integer
          @                      program terminates

oo

在线尝试。

唯一会影响输出的是“ 5”,它显示5。

认真地

在线尝试。

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•2;#4!@ -[>+<-----]>           assorted stack manipulation that doesn't affect this program
                        6          push 6 to the stack
                         .         output top of the stack
                          §        (0x7f) terminate program

5

ChaîneMinkolangFooBrainf ** k-ngVitsy 5种语言,21/5 ^ 3 = 0.168

2|<«+!@"3".N+m

5N»

脑力激荡

2|<«+!@"3".N+m

5N»
  <            go left (should still be ok)
    +!         output 1
      @        halt execution

沙恩

2|<«+!@"3".N+m

5N»
2              «add 2 to the current string»
 |<            «take off and put on the string (no op)»
   «           «comment»

  »
               «implicit output»

oo

2|<«+!@"3".N+m

5N»
       "3"     print three

Minkolang

2|<«+!@"3".N+m

5N»
2              C push 2 to the stack [2] C
 |             C mirror C
2              C push 2 to the stack [2,2] C
             m C ignored C
            +  C add top two [4] C
           N   C output C
          .    C terminate program C

维蒂

2|<«+!@"3".N+m

5N»
2              push 2
 |             mirror
2              push 2
             m pop 2, goto line 2
5              push 5
 N             output 5
  »            ignored

我可能可以添加> <>之类的东西。


1
你知道,我从来没有发现镜子的好用处。xD
Addison Crump 2015年

5

CraneflakBrain-Flak ClassicRain-FlakBrainHackBrain-FueueminiflakminiHack:.1020

(([]()()()<()()()>)()()){}#{}({}())

在线尝试!

说明

首先要做的是,BrainHack,CraneFlak和Rain-Flak解释器的注释阅读方式有所不同。Craneflak没有评论,Rain-Flak则#评论其余部分,BrainHack则#{...}评论内部。

所以这是每种语言的读法:

Rain-Flak: (([]()()()<()()()>)()()){}         -> 3
BrainHack: (([]()()()<()()()>)()()){}({}())   -> 4
Craneflak: (([]()()()<()()()>)()()){}{}({}()) -> 1

接下来的事情是大脑侧翼和微型侧翼之间的差异。Rain-Flak和BrainHack都支持miniflak,只需删除所有多余的操作即可。这意味着他们失去了[]<...>

Rain-Flak: (()()()()()())         -> 6
BrainHack: (()()()()()())({}())   -> 7

接下来,我们了解Brain-Flak和Brain-Flak Classic之间的区别。在经典[]-1不是堆栈高度,这意味着我们的结果比常规Rain-Flak小1,使其成为2。

最后,我们得出了“脑动弹”和“脑通气”之间的区别。在脑流中,使用队列而不是堆栈。通常情况下,先后按先3后再按5,然后将5弹出,但是在脑通量中,先后流行会摆脱3,而不是5。


4

银河1.0.2CJamSTXTRM,20字节/ 3 ^ 3 = 0.741

我想至少可以添加一种其他语言。

'2"3""1"1<<1>;;"2"3;

说明


银河系1

在银河系中,字符串仅用双引号对表示。单引号从命令行读取输入。如果不存在,它将推送一个空字符串。大于和小于符号将使整个堆栈分别向右和向左旋转。最后,分号交换前两个堆栈元素。

这是堆栈可视化(显示的堆栈是列出的操作发生后的结果):

["", 0]                                             #  default stack

["", 0, ""]                                 #   '   #  read input from command line
["", 0, "", 2]                              #   2   #  push 2 to the stack
["", 0, "", 2, "3"]                         #  "3"  #  push "3" to the stack
["", 0, "", 2, "3", "1"]                    #  "1"  #  push "1" to the stack
["", 0, "", 2, "3", "1", 1]                 #   1   #  push 1 to the stack
[0, "", 2, "3", "1", 1, ""]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0, 1]              #   1   #  push 1 to the stack
[1, "", 2, "3", "1", 1, "", 0]              #   >   #  rotate the stack rightward
[1, "", 2, "3", "1", 1, 0, ""]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0, "", 2]       #  "2"  #  push 2 to the stack
[1, "", 2, "3", "1", 1, "", 0, "", 2, "3"]  #   3   #  push "3" to the stack
[1, "", 2, "3", "1", 1, "", 0, "", "3", 2]  #   ;   #  swap the top two stack elements

CJam2

在CJam中,字符串也用双引号对表示。单引号会推后一个字符的字符代码。输出字符代码时,将其输出为对应的字符。大于和小于符号按预期方式工作,评估了顶部两个堆栈元素的顺序。最后,分号将顶部堆栈元素丢弃。程序终止时,将输出堆栈的内容。

这是堆栈可视化(显示的堆栈是列出的操作发生后的结果):

[]                         #  default stack

['2]               #  '2   #  push the character code of "2" to the stack
['2, "3"]          #  "3"  #  push "3" to the stack
['2, "3", "1"]     #  "1"  #  push "1" to the stack
['2, "3", "1", 1]  #   1   #  push 1 to the stack
['2, "3", "1"]     #   <   #  leave the greater of the top two stack elements on the stack
['2, 0]            #   <   #  leave the greater of the top two stack elements on the stack
['2, 0, 1]         #   1   #  push 1 to the stack
['2, 1]            #   >   #  leave the lesser of the top two stack elements on the stack
['2]               #   ;   #  pop the top stack value
[]                 #   ;   #  pop the top stack value
['2]               #  "2"  #  push the character code of "2" to the stack
['2, "3"]          #   3   #  push "3" to the stack
['2]               #   ;   #  pop the top stack item

STXTRM3

在MSM中,任何不是运算符的内容都作为字符被压入堆栈。分号复制顶部堆栈元素。程序将继续执行,直到没有更多的运算符,或者堆栈上只有一个元素为止。

堆栈上的最终字符是3,由最终运算符重复。3是程序末尾的最高元素,因此将其输出。


4

5种语言,18个字节/ 5 ^ 3 = 0.144

衔尾蛇Pip,QBasic,Foo和Pyth

5'"4"()"
1?3'@n()2

1.衔尾蛇

程序的每一行代表一条蛇在吃它的尾巴。

蛇1

Push 5'是无操作的push 52(ASCII码为"4")。(使蛇弹出一个数字并吃掉它尾巴上的那么多字符。因为这导致吞没指令指针(和整个蛇),所以执行停止。

蛇2

1,推随机数(?),推3'是一个空操作。@将旋转1到堆栈顶部并n输出为数字,而将其保留3在堆栈顶部。然后(从蛇尾吃掉这么多字符,吞下指令指针并停止。

您可以在此处的Stack Snippet解释器中在线运行此程序。

2.点

该程序大多数由表达式组成,这些表达式被评估并丢弃:

  • 5
  • '" (字符文字)
  • 4
  • "()"
  • 1?3'@ (三元表达式)
  • n (变量,=换行符)
  • () (零)

最后,输出最后一个表达式2

3. QBasic

之后的所有内容'均为评论。因此,第一行归纳5为行号。在第二行,1是行号,?3是的快捷方式PRINT 3

(显然,行号乱序不是问题,尽管如果很容易解决,则很容易解决。)

4. Foo

几乎所有东西都没有。"4"版画4。括号(x2)是一个循环,一直运行到当前数组单元为零(立即为真)并退出循环为止。@如果不带数字,则采用当前数组单元的值(初始化为0)并将其压入堆栈。

我不确定要如何处理第二个不匹配的问题"。在网络版,似乎一个新行添加到输出,其挑战的规则允许。

5. Pyth

5输出。然后程序遇到'"4",该程序尝试从名为的文件中读取4。只要不存在这样的文件,我认为这应该以错误终止程序。(在线版本name 'open' is not defined-我想是因为不允许在线打开文件。)

"1行末尾的流浪确保了第2行在执行之前不会引起语法错误。



@丹尼斯谢谢!“ Esolangs”页面没有指向该解释器的链接。
DLosc '16

这是当前可用语言的索引。如果您要我添加一个,只需在聊天中ping我即可。
丹尼斯

4

4种语言,24个字节,24/4 ^ 3 = 0.375

print(1//0.5--1+1/2*2
);

1. PHP

PHP执行print(1);等于1

2. Lua

Lua执行print(1//0.5);等于2

3. Python 2

Python 2执行print(1//0.5--1+1/2*2);等于3(整数除法)的代码

4. Python 3

Python 3执行print(1//0.5--1+1/2*2);等于4(浮点除法)的代码


不错的答案,我喜欢常规语言的答案:-)希望您在ppcg上打高尔夫球很开心:-)如果您认为我以前的挑战很有趣,请尝试一下我以前的任何挑战:-)有些棘手,有些则更多基本:-)
Stewie Griffin

您可能对挑战中描述的100个公开赛奖金感兴趣。Outgolf Sp3000(28字节,4种语言)仅使用常规语言(在链接中定义),而这是您自己的:-)不幸的是,在赏金挑战中,python 2和3并不是唯一的。
Stewie Griffin

3

Brainfuck-ng,Foo,> <>,​​9字节/ 3 ^ 3 = 0.333 ...

#+!"2";n3

脑力激荡

它识别的唯一字符是+!

+ Increment cell by one
! Print as integer

版画 1

oo

用引号打印所有内容。

"2"

版画 2

> <>

#将点镜像到左侧,33压入堆栈,将其n输出为整数,;停止程序。

#      ;n3

2

3种语言,82 83/3 ^ 3 = 3.074 ...

适用于??? WhitespaceBeatnik。或者更确切地说,它应该在那些语言下工作,但我几天将无法对其进行测试。无论如何,这是代码:

K... Jax... Jy... Jy...   ...
My...    My...
... ...     ......................XO!

1。???

.................................................!

??? 基本上是头脑操,但它使用普通标点符号作为命令而不是传统字符。.将当前存储单元加1,完成49次。!接受当前的存储单元并在此处将其打印为字符1

2. 空格

[Space][Space][Space][Tab][Line Feed]
[Tab][Line Feed]
[Space][Tab]

空格是一种忽略所有非空格字符的语言。在这里,我将其转换为易于阅读的形式。第一行压2入堆栈,后两行将堆栈顶部打印为数字(此处为)2
请注意,由于技术限制,在组合的代码中,我用四个空格代替了制表符。

3. Beatnik

K Jax
Jy Jy
My My
XO

Beatnik是一种语言,其中每个单词都将转换为其Scrabble分数,然后将这些分数解释为命令。第一行压17入堆栈。第二行复制该堆栈的顶部两次和第三线路增加了顶部堆叠的元件一起两次,有效三倍1751。最后一行将字符打印在堆栈的顶部(此处为)3
请注意,假设原始Beatnik规格中没有错误,我将以Face Value使用Beatnik。另请注意,我使用的是北美英语拼字游戏评分系统。

如果现在还不清楚,那么每种语言都只能接受某种类型的字符(分别为标点符号,空格和字母),因此编写此多语言与编写单个程序一样容易。唯一真正的“技巧”是使用空格代码将单词与Beatnik分开。除此之外,各个程序不会重叠。


2
3 ^ 3 = 27 ==> 82/27 = 3.037037037037037 ...
AdmBorkBork

1
您空白代码打印0,不2.测试在这里这里
丹尼斯2015年

@丹尼斯谢谢,我已经省略了符号位。
Mike Bufardeci 2015年

2

5种语言,175/5 ^ 3 = 1.4

我决定发布一个不同的答案,因为赏金正在以一种让我对第一个答案感到不满意的方式改变要求(但是,这仍然使我对通用挑战感到满意!)

因此,这是我有资格获得赏金挑战的解决方案:

它编译在

  • C99
  • objC90
  • C ++ 0x
  • 红宝石
  • 佩尔
#if __cplusplus
#define x\
=begin\
=pod
#endif
int a=
#ifndef x
1//**/
+1
#else
3
#endif
;int main(){printf("%d",a);}
#ifdef f
=end
puts 5;
=begin
=cut
print"4";
=end
#endif

2

3种语言,15个字节,得分0.555 ...

稍后会添加更多语言。

2//1+1#😅😨

1.表情学

Emotinomicon几乎会忽略不是字符串的任何文本。😅按1进行堆栈并😨输出TOS作为数字。

2. Javascript

Javascript中的注释以开头//,因此仅2执行该部分。

3. Python 2/3 REPL

Python中的注释以开头#,因此仅2//1+1执行该部分。//是Python 3中的整数除法,它与/Python 2中的相同。2除以1为2,加1为3。


2

4种语言,97个字节,0.37890625

s="1";s=~-3;2//2;'''/.to_s.ord;"=;print 4;
__DATA__
=1;
";#'''#";print=s=>console.log(3)
print(s)

红宝石

这台s"1",比较了使用=~-3在无效的情况下,试图分裂2/2;'''/.to_s.ord然后开始包含一个新的字符串=;print 4; __DATA__ =1;,打了注释,那么print小号s这仍然是1

蟒蛇

设置s"1"按照以上,然后再次将其设置为~-32。我们对进行整数除法2//2,然后有一个docstring,其中包含/.to_s.ord;"=;print 4; __DATA__ =1; ";#,后跟一个注释,最后是printing s,它仍然是2

的JavaScript

设置s为,"1"然后再次将其设置~-3为,如上所示,然后2是一行,后接注释。然后,将变量设置__DATA__1。有一个短字符串,其中包含;#'''#紧随其后的函数定义,该函数print将输出硬编码为3,在下一行调用该函数。

佩尔

运行等效于s/"1";s/~-3;2\/\/2;'''\/.to_s.ord;"/print的替换,4字符串的其余部分在__DATA__标识符后面被屏蔽。


2

QBasic,QBIC和> <>,​​18字节/ 3 ^ 3语言= 0.66666点

1:?v+1'-5`
''`>3n;

分解:

1. QBasic(获取IDE

1:          Line number 1
  ?         Print
   v+1      undefined var v = 0 + 1 = 1
'-5`        The rest of theis code is a QBasic comment
''`>3n;     As is this

2. QBIC(获取口译员

1     inserts a 1 in the code - mostly harmless
:     Reads from the cmd line. Nothing there, creates an empty variable a
?     Print
v+1   v is initialised to 6, +1 = 7
'     Code Literal: everything till the ` is passed to QBasic without processing
 -5`  7-5 = 2

''`>3n; Code literal with the first literal being a ': comment in QBasic

3.> <>(在线尝试

1:  Push a 1 on the stack, duplicate stack
?   Pop top off the stack and skip next instruction if that's a 0
v   Move downwards - rest of the line is ignored

>   move to the right
3   Push 3 onto the stack
n   Print the top of the stack as a number
;   End the program

1
我认为您想对自己分数中的语言数量(例如18 /(3 ^ 3))求立方
数学迷

1

JavaScript,HTML和PHP,72字节/ 3 ^ 3 = 2.67

1<!top?2:2//><!--<?='--'.'><script>document.body.innerHTML=3</script>'?>

在HTML中,这将打印开头的1(忽略<!window?2:2//>标记),其余为HTML注释。

在JavaScript中,它评估1<!window?2:2并输出2(必须在控制台中运行),其余为注释。

在PHP中,以下是来自服务器的输出:1<!top?2:2//><!----><script>document.body.innerHTML=3</script>它取代HTML的1使用3


1
欢迎来到PPCG.SE!很棒的第一篇文章!两件事:我们通常不喜欢基于REPL的答案(JavaScript程序)。此外,当我将其放入在线解释器中时,PHP代码似乎未运行,PHP到底如何工作?
GamrCorps,2015年

谢谢!嗯,这是技术上的PHP + HTML(即,如果这是code.php的源代码,访问网站/ code.php在浏览器中显示3
cuniculus

在这里尝试:mowbl.com/se.php
cuniculus
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.