众所周知，确定Turing机器是否停止运行还不确定，但是对于较简单的机器而言并不一定如此。

甲富机是一台具有有限带，其中在磁带上的每个小区具有整数或halt符号h，例如

2 h 1 -1

指令指针从指向第一个单元格开始：

2 h 1 -1
^

在每一步中，指令指针都向前移动其指向的数字，然后取反该数字。因此，经过一步，它将向前移动2单元格，并将其2变为-2：

-2 h 1 -1
     ^

Foo机器会继续执行此操作，直到指令指针指向暂停符号（h）。因此，这是该程序的完整执行：

2 h 1 -1
^

-2 h 1 -1
     ^

-2 h -1 -1
         ^

-2 h -1 1
      ^

-2 h 1 1
   ^

磁带也是圆形的，因此，如果指令指针从磁带的一侧移开，它将移到另一侧，例如：

3 h 1 3
^
-3 h 1 3
       ^
-3 h 1 -3
     ^
-3 h -1 -3
         ^
-3 h -1 3
 ^
3 h -1 3
  ^

这些Foo机器的有趣之处在于，有些机器不会停止运行，例如：

1 2 h 2
^
-1 2 h 2
   ^
-1 -2 h 2
        ^
-1 -2 h -2
    ^
-1 2 h -2
        ^
-1 2 h 2
   ^

该程序将永远在最后四个状态中继续循环。

因此，编写一个确定Foo机器是否停止的程序！您可以为Foo机器使用任何（合理的）输入格式，也可以选择0用作停止符号。您可以在停止和不停止两种情况下使用任意两个不同的输出。当然，您的程序必须在有限的时间内为所有有效输入输出答案。

这是代码高尔夫，所以请尝试使程序尽可能短！

测试用例

2 h 1 -1
Halts
3 h 1 3
Halts
h
Halts
1 1 1 1 h
Halts
2 1 3 2 1 2 h
Halts
3 2 1 1 4 h
Halts
1 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 h -20 -21 -22 -23 -24 -25 -26 -27 -28 -29 -30 -31 -32 -33 -34 -35 -36
Halts

2 h
Does not halt
1 2 h 2
Does not halt
8 1 2 3 3 4 8 4 3 2 h
Does not halt
1 2 4 3 h 2 4 5 3
Does not halt
3 1 h 3 1 1
Does not halt
1 2 h 42
Does not halt

C＃（Visual C＃交互式编译器），71字节

x=>{for(int i=0,k=0,f=x.Count;i++<1<<f;k%=f)k-=(x[k]*=-1)%f-f;i/=x[k];}

在线尝试！

我不知道以下内容是否有效，因为它需要具有签名的自定义委托，unsafe delegate System.Action<int> D(int* a); 并且必须包装在unsafe要使用的块中，但是无论如何这里都是这样：

C＃（.NET Core），64字节

x=>f=>{for(int i=0,k=0;i++<1<<f;k%=f)k-=(x[k]*=-1)%f-f;k/=x[k];}

在线尝试！

该函数接受一个int *并返回一个Action；换句话说，这是一个咖喱函数。我使用指针的唯一原因是因为codegolf.meta.stackexchange.com/a/13262/84206，它使我可以通过已经有一个定义了数组长度的变量来节省字节。

@someone节省了9个字节

Python 3中，63 89个字节

def f(x):
 for i in range(2**len(x)):a=x[0];x[0]=-a;b=a%len(x);x=x[b:]+x[:b]
 return a==0

在线尝试！

也适用于Python 2；可以在Python 2中保存一个字节，方法是将print替换为return，并将函数print替换为stdout而不是return。R转为True暂停和False非暂停。

感谢@Neil和@Arnauld指出我需要检查更长的时间才能停止。感谢@Jitse指出的问题[2,0]。感谢@mypetlion指出磁带值的绝对值可能会超过磁带长度。

果冻，15 11字节

N1¦ṙ⁸ḢƊÐLḢẸ

在线尝试！

将输入作为整数列表（使用0表示暂停）的单子链接。返回0表示停止输入，返回1表示不停止输入。

避免了需要计算迭代次数的问题，因为使用迭代ÐL会一直循环直到看不到新结果。

感谢@JonathanAllan节省了一个字节！

说明

      ƊÐL   | Loop the following as a monad until the result has been seen before:
N1¦         | - Negate the first element
   ṙ⁸       | - Rotate left by each of the elements
     Ḣ      | - Take just the result of rotating by the first element
         Ḣ  | Finally take the first element
          Ẹ | And check if non-zero

Python 3，91字节

def f(a):
	s={0,};i=0
	while{(*a,)}-s:s|={(*a,)};a[i]*=-1;i-=a[i];i%=len(a)
	return a[i]==0

在线尝试！

-40个字节，得益于JoKing和Jitse

Perl 6的，46个43 36字节

{$_.=rotate(.[0]*=-1)xx 2**$_;!.[0]}

在线尝试！

表示暂停，0如果机器停止，则返回true。这会重复逻辑2**(length n)时间，如果指针最终停在停止单元格上，它将停留在那里，否则指针将处于非停止单元格上。之所以2**n可行，是因为Foo机器仅处于可能的状态（忽略暂停单元），因为每个非暂停单元只有两个状态。好的，是有状态的，但是由于指针（以及状态）之间可能的转换有限，所以少于2 ** $ _个状态...我认为

说明

{                                  }  # Anonymous codeblock
                     xx 2**$_         # Repeat 2**len(n) times
            .[0]*=-1                  # Negate the first element
 $_.=rotate(        )                 # Rotate the list by that value
                             ;!.[0]   # Return if the first element is 0

05AB1E，14 13字节

goFć©(š®._}®_

在线尝试！

将输入作为整数列表，其中0作为暂停指令。返回1表示停止，返回0表示不停止。

感谢@KevinCruijssen节省了2个字节！

Java 8，78 79 73字节

a->{int k=0,l=a.length,i=0;for(;i++<1<<l;k%=l)k-=(a[k]*=-1)%l-l;k/=a[k];}

@EmbodimentOfIgnorance的C＃.NET答案的直接端口，因此请确保对他进行投票！
感谢@Arnauld找到了两个错误（这也适用于其他答案）。

java.lang.ArithmeticException: / by zero能够暂停时会导致错误，否则将不会导致错误。

在线尝试。

说明：

a->{                   // Method with integer-array as parameter and no return-type
  int k=0,             //  Index integer, starting at 0
      l=a.length,      //  The length `l` of the input-array
  i=0;for(;i++<1<<l;   //  Loop 2^length amount of times:
          k%=l)        //    After every iteration: take mod `l` of `k`
    k-=                //   Decrease `k` by:
       (a[k]*=-1)      //    Negate the value at index `k` first
                 %l    //    Then take modulo `l` of this
                   -l; //    And then subtract `l` from it
                       //  (NOTE: the modulo `l` and minus `l` are used for wrapping
                       //  and/or converting negative indices to positive ones
  k/=a[k];}            //  After the loop: divide `k` by the `k`'th value,
                       //  which will result in an division by 0 error if are halting

Haskell，79个字节

s x|m<-length x,let g(n:p)=(drop<>take)(mod n m)(-n:p)=iterate g x!!(2^m)!!0==0

在线尝试！

返回True停止机器，False否则返回。以列表的形式输入，0表示停止状态。

假设GHC的版本大于8.4（2018年2月发布）。

JavaScript（Node.js），71 67字节

x=>{for(p=l=x.length,i=2**l;i--;)p+=l-(x[p%l]*=-1)%l;return!x[p%l]}

基本上与@EmbodimentOfIgnorance的C＃.NET答案相同

@Arnaud节省了4个字节

在线尝试！

JavaScript（Node.js），61字节

x=>{for(p=l=x.length,i=2**l;i--;p+=l-(x[p%l]*=-1)%l)x[p%l].f}

此版本undefined用作停止符号，并TypeError: Cannot read property 'f' of undefined在机器停止时抛出，并在机器不停止时安静地终止。

在线尝试！

Scala，156字节

仍然可以打高尔夫球的IMO，但我现在还可以。返回0非停止Foos和1停止Foos。将输入a作为Array[Int]，因此h作为0。

var u=Seq[Array[Int]]()//Keep track of all states
var i=0//Index
while(u.forall(_.deep!=a.deep)){if(a(i)==0)return 1//Check if we are in a previously encountered step ; Halt
u:+=a.clone//Add current state in the tracker
var k=i//Stock temp index
i=(a(i)+i)%a.length//Move index to next step
if(i<0)i+=a.length//Modulus operator in Scala can return a negative value...
a(k)*=(-1)}//Change sign of last seen index
0//Returns 0 if we met a previous step

由于我进行了多次全阵列查找，.deep而且创建了副本，因此运行时间非常长（所有测试用例大约需要4秒钟），但是您仍然可以在线尝试。

Perl -ap 5，88个字节

for(;$F[$i]&&!$k{"$i|$F[$i]"};$i=($i+$F[$i])%@F){$k{"$i|$F[$i]"}=1;$F[$i]*=-1}$_=!$F[$i]

在线尝试！

附件，40字节

Not@&N@Periodic[{On[0,`-,_]&Rotate!_@0}]

在线尝试！

说明

{On[0,`-,_]&Rotate!_@0}

这将对Foo机器执行一次迭代。它使第一个成员取反，然后通过数组的（原始的，非取反的）第一个元素旋转数组。

Periodic将应用此功能，直到积累重复的结果。机器要么停止，要么陷入微不足道的无限循环。如果停止，则第一个元素将为0。否则，它将为非零。

&N是一种获取数值数组第一个元素的方法。然后，Not返回true0（停止机器）和false其他任何值（非停止机器）。

木炭，28字节

≔⁰ηＦＸ²Ｌ諧≔θ籧θη≧⁻§θη绬§θη

在线尝试！链接是详细版本的代码。使用Charcoal的默认布尔输出的输出，该输出-为true，否则为false。说明：

≔⁰η

初始化指令指针。

ＦＸ²Ｌθ«

循环尽可能多的状态，理论上是可能的状态。

§≔θ籧θη

在指令指针处取反值。

≧⁻§θηη

从指令指针中减去新值。木炭的数组访问是循环的，因此这会自动模拟Foo的圆形磁带。

»¬§θη

在循环结束时，输出程序是否暂停。

Stax，11 个字节

Ç₧┬òE▐tµ|⌡1

运行并调试

它以整数数组的形式接受输入，并0表示停止。

它1为停机和0非停机机器输出。

Pyth，12个字节

!hu.<+_hGtGh

测试套件！

使用简单明了的方法。递归直到我们两次看到相同状态的列表。对于暂停的程序，该列表最终将处于领先地位，0因为这是递归停止的地方。对于不停止的程序，列表不会以开头0，而是处于周期性处理的状态，因此Foo机器不会停止。