密码梯，强盗

24

这是强盗的线索。警察的线索在这里。

编写一个代码，该代码与cop post具有相同的字节数，并且显示的字符相同。该代码必须1在其初始状态下产生，并2, 3 ..在进行单个更改时产生数字。

获胜者将是破解最多职位的强盗。

示例帖子：

MyLang，9个字节，8个数字（包括答案​​链接），Cop的用户名。

原始代码：

abc1efghi

产生1-8的代码：

1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi

鼓励解释。强盗帖子的确切格式是可选的。

cops-and-robbers 
— 斯蒂夫·格里芬
source

Answers:

13

Retina，2字节，10个数字，由Martin Ender提供。

原始代码：

1个

这将空输入替换为数字1。

产生1-10的代码（\n为方便起见，显示换行符）：

1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n

对于2及更高版本，我们计算上一阶段中的空字符串数。对于2，在1之前和之后有一个空字符串。对于3，在它们之间，之间和之后有一个空字符串。一直到10。

在线尝试

— 弗莱姆·埃格曼
source
8

Perl，12个字节，10个数字，由 Ais523提供

原始代码：

____;say__-9

产生1-10的代码：

wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0

说明： 

wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9
— 赖利
source
7

ETHproductions的 JavaScript，30字节，10个数字。

原始代码：

1: alert(Array(2).join(3).length)

其他号码

 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)

说明

Array(2)创建一个具有两个空单元格的数组。该.join方法使用定界符将Array中的所有元素连接在一起，该定界符将其转换为String。在原始代码中，定界符为3。这意味着将数组中的两个空单元连接在一起用作3分隔符。此计算"3"为，3由于Array为空，因此在的两边都没有任何内容。并且由于lengthof "3"是1，因此将该值输出到控制台。

对于其他数字，我在连接数组元素的定界符上再加上1个数字。因此，这增加了其长度，从而alert增加了值。请注意，定界符的数值并不重要，只有其长度才重要。

零食片段！

注意：出于明显的原因，我在Snack Snippet中使用console.log而不是alert。同样，来自控制台的输出也显示在代码段中。

console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)
展开摘要

— 克里蒂希·石印
source
1
真好！那是预期的解决方案（尽管我对连接号不是很想像；））
— ETHproductions 2016年
7

八度，17字节，10个数字，作者Stewie Griffin

original:
_i_(__i__(2_5_))

solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))
— 瑕疵
source
嗯，还远远没有我解决！做得好！:)我会在我的帖子中张贴预期的帖子：）
— Stewie Griffin
7

Python 2，17个字节，10个数字，xnor

print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])

代表

— 乔纳森·艾伦
source
7

Python 2、9个字节，10个数字，xnor

print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74
— Sp3000
source
1
恭喜！那也是我想到的那个。我很好奇，并进行了搜索。事实证明，有许多解决方案，包括不使用按位运算的解决方案。
— xnor
print 10/10&根据树形搜索，如果您禁止它，那将是一件非常有趣的事情。或者，如果您需要转到
— 11。– xnor
6

Perl，14字节，10个数字，作者Dada

原始代码：

say_!"___"%""_

产生1-10的代码：

  1. say"!"+1#"%""r
  2. say"!"+2#"%""r
  3. say"!"+3#"%""r
  4. say"!"+4#"%""r
  5. say"!"+5#"%""r
  6. say"!"+6#"%""r
  7. say"!"+7#"%""r
  8. say"!"+8#"%""r
  9. say"!"+9#"%""r
  10. say"1"+9#"%""r

我觉得这不是你想要的。

— 社区
source
1
我应该有更多字母...原始代码是say"!"=~y"%""c（so say"!!"=~y"%""c，等等，!每次都多一个）。但是很好玩！:)
— Dada
正确，有足够的空隙可以将整数常量潜入中间并注释掉该行的其余部分。在这样的挑战中，这似乎很危险。
1
我不想提供太多信息：=否则~可能会有很大的暗示，并且"正如我所展示的，它们的结构具有误导性（我希望）……但是我应该考虑评论其中一半是可行的！
— 达达
我实际上猜到=~了预期的解决方案。不过，我正忙着s，m并/没有想到的y。
1
欢迎使用PPCG！很高兴见到新的perl高尔夫球手！
— 达达
6

JavaScript，22字节，10个数字，由 Arnauld撰写

原始程序：

alert(0_6_4_>_0_2_0_7)

破解：

  1. alert(0+6^42>101210^7)
  2. alert(0+5^42>101210^7)
  3. alert(0+4^42>101210^7)
  4. alert(0+3^42>101210^7)
  5. alert(0+2^42>101210^7)
  6. alert(0+1^42>101210^7)
  7. alert(0+0^42>101210^7)
  8. alert(0+0^42>101210^8)
  9. alert(0+0^42>101210^9)
  10. alert(0+3^42>101210^9)

困难的部分是处理>，它的优先级非常低。我尝试将其更改为an >>，但是最简单的方法是通过使它无用地计算42>101210数值为0 的布尔false（该部分）来吸收它，并使用优先级甚至比更低的运算符从1到10生成数字>。我使用了^按位异或运算，因为它可以很容易地生成1到10之间的数字（方便的是，原始输入中的6和7让我简化了表达式直到6^71）。

— 社区
source
5

JavaScript，9个字节， Hedi

原始代码：

alert(+1)

修改内容：

alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10
— ETH生产
source
5

八度，55字节，10个数字，瑕疵

(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)

决赛 1可以循环到9，然后将更+1改为+2。

— 费瑟姆
source
干得好，您是否找到了关于此事的我的帖子？:)
— 瑕疵的
@flawr嗯？关于什么？
— feersum '16
哦，我看到您在原始文章中写了一些关于递归函数的内容。我的破解不使用任何递归。
— feersum '16
哦，现在我明白了，乍看之下我什至无法分辨两者之间的差异^^
— 更加模糊的
5

Python 3、16个字节，10个数字，由 Sp3000

很好玩

print(?%??f?r?t)

print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)

利用了一个事实（直到现在我还不知道），十六进制文字会在0-9a-fA-F遇到不存在的字符时立即结束-因此这0xfor是一种非常偷偷摸摸的书写方式15 or。之后，要找到与10模15一致的正确值。

— DLosc
source
快速：P但是，它至少应该是显而易见的，现在怎么bin()一个旨在过于解决。
— Sp3000 '16
5

JavaScript，22字节，由Arnauld撰写的 10个数字

原始代码：

alert(__14_337__xc_de)

已修改：

alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10

我猜这不是预期的解决方案，但我希望它不会太遥远...

— 唐·黑斯廷斯
source
那确实是预期的解决方案。做得好！
— Arnauld
2
确实应该alert(0140337-0xc0de)（短一字节），但是我错误地使用了ES6八进制表示法，0o140337并决定采用这种方式。
— Arnauld
@Arnauld我很高兴我能够获得“正确的”解决方案！感谢您的挑战！
— Dom Hastings
4

八度，32字节，10个数字，作者Luis Mendo

原始代码：

nnz(isprime(floor(s=3):i*-2i))+1

修改后的代码：

2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7

这里有许多修改方法（例如s=2，+0在开始时）。

编辑：一个更可能的替代方法：

nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9
— 斯蒂夫·格里芬
source
4

05AB1E，11字节，10个数字，作者Oliver

原始代码：

 1: 3628801zï0>

其他号码

 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>

说明

3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output

总结一下，push 3628801，取其倒数并将其四舍五入到最接近的整数（计算为0）。然后增加堆栈。TADA！

在线尝试！对于输出= 1，然后>根据要输出的数量添加任意多的s。

— 克里蒂希·石印
source
4

JavaScript，12个字节，10个数字，Hedi

原始代码：

alert(+[+1])

2至10：

alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])

您可以用这么多的代码做很多事情...

— ETH生产
source
1
“您可以使用这么多的代码来做很多事情……”但是您找到了我没有想到的解决方案^^'我不需要的解决方案+。
— Hedi
4

果冻，7个字节，10个数字， Jonathan Allan

原始代码：

“1‘ỌȮḊ‘

然后：

“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘

您可以在TryItOnline上查看最后一个！

另一种方式是

“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘
— 赫迪
source
4

八度，21字节，10个数字，作者Stewie Griffin

这fpr是一个很好的误导=）但我喜欢这个(1') -> 2(1') -> 2+(1')顺序！

original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))
— 瑕疵
source
该顺序确实是一个不错的技巧！
— 路易斯·门多
4

六边形，7字节，10个数字，作者：Martin Ender

原版的：

1<@|!__

产生1-10的代码：

1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!

1：在线尝试！
9：在线尝试！
10：在线尝试！

这是前9个程序的十六进制（其中＃是您要打印的数字）：

 # <
@ | !
 ) .

存储器边缘仅设置为要打印的值，并偏转到SE并打印。

和十六进制：

  9 < @
 | ! ) .
! . . . .
 . . . .
  . . .

在这里，我在末尾添加了一个字符，以增加十六进制大小。首先，将存储器边沿设置为9，将指针偏转到SE，将内存增加，回绕，将指针偏转到SW，打印值，然后程序结束。

这是第二种解决方案：

1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)

1：在线尝试！
9：在线尝试！
10：在线尝试！

1-9的十六进制（这次*是要打印的数字）：

 * <
@ | !
 $ )

与上面的1-9相同。

十六进制：

 9 #
@ | !
 $ )

点击9后将#指令指针切换到右下角，内存增加到10，$越过!，指针反向向东反转，在那儿跳过)并结束。

— 赖利
source
1
棒极了。：DI试图设计一个警察，使这两个解决方案（边长为3并#在9上使用）成为可能，但最终都以警察的方式出现，这些警察也有无聊的捷径。我一直在寻找是否有一种方法可以使#解决方案与|中心一起工作，但没有找到解决方案。无论如何都可以很好地解决这个问题！:)
— 马丁·恩德
4

C＃，90个字节，10个数字，Scepheo

原版的：

using ______________________________________________;class C{static void Main(){_______;}}

第一：

using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}

然后：

using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}
— 赫迪
source
这正是预期的解决方案。辛苦了
— Scepheo
...尝试了相同的操作，但是在ideone上出现了奇怪的编译器错误...知道这很明显...
— masterX244
4

Ruby，81个字节，10个数字，histocrat

原始代码：

x=##/=#%#
)
###x

破解：

x=/$/=~%q
)

p x

这是一个棘手的问题。被发现的许多角色竟然是红鲱鱼！/不是除法，而是正则表达式文字的一部分。%不是mod，而是不常见的字符串文字语法的一部分。该程序仅打印由换行符分隔的字符串的长度。可以通过在第二行中插入其他字符来获得后续程序。

— xsot
source
这与我预期的解决方案非常相似，但我的不使用p-~x。您能指出正确解释的Ruby版本吗？在两个我在本地具有的p~-x作品中，但p-~x被解释为p()-~x导致undefined method '-' for nil错误。
— histocrat
@histocrat感谢您指出这一点。我认为它会工作，并且没有对其进行测试。希望您能想到此编辑。
— xsot
甚至更近，但是打印效果0没有改变。还剩下最后一招。
— 历史学家
@histocrat我想我终于明白了。
— xsot
D！做得好:)
— 历史学家
3

八度，25字节，10个数字，作者Luis Mendo

mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))
— 瑕疵
source
— Luis Mendo
3

HM（Aheui），19字节，10个数字，由JHM

原始代码：

봃法희
반자뭉

改性：

2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉
— 吉米23013
source
3

八度，24字节，9个数字，由fracer提供

max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%

八度，24字节9 10数字

注意：此破解适用于cop post的第一个版本（发布了错误的代码段），显示的代码如下所示：___a__repmat(__one__),__)。正确的版本在上面。

原始代码：

+mean(repmat(1,ones(),1))

打印2-10的修改后的版本

1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))
— 斯蒂夫·格里芬
source
3

JavaScript，15个字节，10个数字， ETHProductions

原始代码：

alert( +"+1"+0)  // Prints 1

程式：

alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10
— 阿德南
source
3

八度，21个字节，9个数字， 由fracer提供

我真的很喜欢这个……聪明:)

a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)
— 斯蒂夫·格里芬
source
1
什么
— 鬼
什么？你在跟我开玩笑吗？我的天哪
— Stewie Griffin
好吧，我现在将发布我的解决方案=）
— 更加模糊的
3

加速！，10个字节，9个数字，由DLosc

原始代码：

Write 49+_

产生数字1到9：

Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8

49是的ASCII码1。_默认情况下包含0（因此49+_ = 1）。并Write打印对应于其参数的ASCII码的字符。非常简单。

— 达达
source
3

Python 2，49个字节，10个数字，AlexRacer

也许（也许）是预期的解决方案，但是如果这样，那么可能已经浪费了很多字节：

y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])
— Boboquack
source
爆炸我直到要提交我的通知时才注意到您已经破解了它。我做到了：y=10*6;s='0910_____1';print int(s[8+(y>4or-6):y])将决赛1更改为2，...，9然后*更改为-：repl.it/EW5q :(
— Jonathan Allan
哇，好人，我知道我藏了太多角色:)
— AlexRacer
3

Befunge-93，11个字节，10个数字，James Holderness

905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@

在线尝试！

可能不是预期的解决方案。

我所做的就是5:*通过乘以25来摆脱讨厌的25（）0。如果我们将a 9放在开头，那么输出将是9 - N需要N从单个命令生成的地方。唯一的问题是-1获取10，但是如果没有输入，则尝试读取整数方便地按下a -1。

— 马丁·恩德
source
3

05AB1E，5字节，10个数字，作者：Adnan。

原始代码：

…[==1

1-10：

…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T

说明：

…[==   3 char string
    1  Push number
— 杂种
source
3

05AB1E，6个字节，10个数字，Adnan

原始代码：

¼ [==q

继续添加¼最多可输出10个：

¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q

在线尝试

怎么运行的：

¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit
— 牛奶
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.