圆形磁带令人兴奋吗？

Question

A Brainfuck导数

让我们定义一个简单的布莱福克-like编程语言。它有一个双向的细胞带，每个细胞有一个小块.所有位元最初都是0。磁带上有一个移动的头，最初在0位置。程序是字符<>01!上的字符串，从左到右执行，语义如下：

• <将头部向左移动一步。
• >将头部向右移动一步。
• 0将0放入当前单元格中。
• 1将1放入当前单元格中。
• !翻转当前单元格。

没有循环，因此n个字符的程序在完全n步之后终止。如果所有单元格在执行结束时都包含0，则程序是无聊的；如果至少有一个1，则程序是令人兴奋的。请注意，没有指定磁带的大小，因此根据实现的不同，它可能是双向无限的，也可能是圆形的。

示例程序

以程序1>>>!<<<<0>!>>>!为例。在无限磁带上，执行过程如下：

     v
00000000000000  Put 1
     v
00000100000000  Move by >>>
        v
00000100000000  Flip
        v
00000100100000  Move by <<<<
    v
00000100100000  Put 0
    v
00000100100000  Move by >
     v
00000100100000  Flip
     v
00000000100000  Move by >>>
        v
00000000100000  Flip
        v
00000000000000

最后，所有的单元格都是0，所以这个程序很无聊。现在，让我们在长度为4的圆形磁带上运行相同的程序。

v
0000  Put 1
v
1000  Move by >>>
   v
1000  Flip
   v
1001  Move by <<<< (wrapping around at the edge)
   v
1001  Put 0
   v
1000  Move by > (wrapping back)
v
1000  Flip
v
0000  Move by >>>
   v
0000  Flip
   v
0001

这一次，有一个数值为1的单元格，所以程序是令人兴奋的！我们看到一个节目是无聊的还是令人兴奋的取决于磁带的大小。

任务

您的输入是<>01!上的一个非空字符串，它表示上述编程语言中的程序。字符数组也是可接受的输入格式。当在无限大的磁带上运行时，这个程序保证是无聊的。你的输出应该是程序令人兴奋的磁带长度的列表。注意，您只需要在短于程序长度的磁带上测试程序。

每种语言中字节计数最低的解决方案是赢家。适用标准的密码-高尔夫规则。

测试用例

> : []
110 : []
1>0<! : [1]
0>>1>0<<>! : [1]
1>>>!<<<<0>!>>>! : [2, 4]
!<!<><<0>!>!<><1!>>0 : [2]
>>!>><>001>0<1!<<!>< : [1, 2, 3]
1!><<!<<<!!100><>>>! : [1, 3]
!!1>!>11!1>>0<1!0<!<1><!0<!<0> : [3, 4]
<><<>>!<!!<<<!0!!!><<>0>>>>!>> : [1, 2, 4]
0>>><!<1><<<0>!>>!<<!!00>!<>!0 : [3]
0000!!!!><1<><>>0<1><<><<>>!<< : []
!>!>!>!>!>1>!>0<!<!<!<0<!<0<!<!<!<1>!>0<<! : [1, 2, 5, 7]
<!!>!!><<1<>>>!0>>>0!<!>1!<1!!><<>><0<<!>><<!<<!>< : [1, 2, 4, 5]
!>1<<11<1>!>!1!>>>0!!>!><!!00<><<<0<<>0<<!<<<>>!!> : [1, 2, 3, 5, 6]

Answer 1

Haskell，119个字节

t#'<'=last t:init t
(h:t)#c|c<'#'=1-h:t|c>'='=t++[h]|1<2=read[c]:t
f p=[n|n<-[1..length p],sum(foldl(#)(0<$[1..n])p)>0]

在网上试试！

函数#是单个命令c的解释器。整个程序p由folding #运行，启动带进入p。f对每个磁带执行p，并保留单元格之和至少为1的那些磁带。

Answer 2

红色，243个字节

func[p][repeat n length? p[b: copy[]insert/dup b 0 n i: 1
parse p[any["<"(i: i - 1 if i < 1[i: n])|">"(i: i + 1 if i > n[i: 1])|"0"(b/(i): 0)|"1"(b/(i): 1)|"!"(b/(i): either b/(i) = 0[1][0])|
skip]]s: 0 foreach c b[s: s + c]if s > 0[print n]]]

在网上试试！

冗长而直接的实现。Red的1索引不允许我通过使用模块化算法循环遍历循环磁带来减少字节数。

不毛之地

f: func[p][ 
    repeat n length? p[
        b: [] 
        insert/dup b 0 n
        i: 1
        parse p[
            some [
                 "<" (i: i - 1 if i < 1[i: n])
               | ">" (i: i + 1 if i > n[i: 1])
               | "0" (b/(i): 0)
               | "1" (b/(i): 1)
               | "!" (b/(i): either b/(i) = 0 [1][0])
               | skip 
            ]
        ]
        s: 0
        foreach c b[s: s + c]
        if s > 0 [print n]
    ]
]

Answer 3

果冻，41字节

JR0ṁð3“1⁺¦01¦¬1¦ṙ1 ṙ- ”s“10!<>”,yẎvЀ⁸Ẹ€T

在网上试试！