การพิจารณาว่าเครื่องทัวริงหยุดการทำงานเป็นที่รู้จักกันดีว่าไม่สามารถตัดสินใจได้ แต่นั่นไม่จำเป็นต้องเป็นจริงสำหรับเครื่องที่เรียบง่าย

เครื่อง Fooเป็นเครื่องที่มีเทป จำกัด ที่ถือในเทปแต่ละคนมีจำนวนเต็มหรือสัญลักษณ์หยุด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 # Interactive คอมไพเลอร์) , 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 * และส่งคืนการกระทำ มันเป็นฟังก์ชั่น curried เหตุผลเดียวที่ฉันใช้พอยน์เตอร์เป็นเพราะ codegolf.meta.stackexchange.com/a/13262/84206 ซึ่งช่วยให้ฉันบันทึกไบต์ด้วยการมีตัวแปรที่กำหนดไว้แล้วตามความยาวของอาร์เรย์

บันทึกแล้ว 9 ไบต์ขอบคุณ @someone

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 ได้โดยแทนที่ return ด้วย print และให้ function print เป็น stdout แทนที่จะกลับมา R เปลี่ยนTrueเพื่อหยุดและFalseไม่หยุดพัก

ขอบคุณ @Neil และ @Arnauld สำหรับการสังเกตว่าฉันต้องตรวจสอบอีกต่อไปเพื่อหยุดพัก ขอขอบคุณที่ @Jitse [2,0]สำหรับการชี้ให้เห็นปัญหากับ ขอบคุณ @mypetlion สำหรับการสังเกตว่าค่าสัมบูรณ์ของเทปอาจเกินความยาวเทป

เยลลี่ , 15 11 ไบต์

N1¦ṙ⁸ḢƊÐLḢẸ

ลองออนไลน์!

ลิงก์ monadic ที่รับอินพุตเป็นรายการจำนวนเต็มโดยใช้ 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และผลตอบแทนจริงหากเครื่องหยุด นี่เป็นการทำซ้ำตรรกะ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];}

พอร์ตต่อตรงของคำตอบ C # .NETของ@EmbodimentOfIgnorance ดังนั้นอย่าลืมโหวตให้เขา!
ขอบคุณ@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)

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]}

โดยทั่วไปเหมือนกับคำตอบ C # .NET ของ@EmbodimentOfIgnorance

4 ไบต์บันทึกด้วย@Arnaud

ลองออนไลน์!

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เป็นสัญลักษณ์หยุดการทำงานและจะส่ง a TypeError: Cannot read property 'f' of undefinedเมื่อเครื่องหยุดและหยุดอย่างเงียบ ๆ เมื่อเครื่องไม่หยุด

ลองออนไลน์!

สกาลา , 156 ไบต์

ยังคงเล่นกอล์ฟได้ IMO แต่ตอนนี้ฉันโอเคแล้ว ส่งคืน0สำหรับ non-halting Foos และ1สำหรับ halting Foos รับอินพุตaเป็น an 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

มันใช้งานได้ค่อนข้างนาน (ประมาณ 4 วินาทีสำหรับกรณีทดสอบทั้งหมด) เนื่องจากการค้นหาแบบเต็มหลายครั้งที่ฉันทำรวมถึงการ.deepสร้างสำเนา ... แต่คุณยังสามารถลองออนไลน์ได้

Perl 5 -ap , 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เป็นวิธี golfy ของการได้รับองค์ประกอบแรกของอาร์เรย์ที่เป็นตัวเลข จากนั้นNotส่งคืนค่าtrueเป็น 0 (เครื่องหยุดทำงาน) และfalseสำหรับสิ่งอื่น (เครื่องหยุดทำงานชั่วคราว)

ถ่าน 28 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เอาต์พุตที่ใช้เอาต์พุตบูลีนดีฟอลต์ของ Charcoal ซึ่งมี-ไว้สำหรับจริงและไม่มีอะไรเป็นเท็จ คำอธิบาย:

≔⁰η

เริ่มต้นตัวชี้คำสั่ง

ＦＸ²Ｌθ«

วนซ้ำหลาย ๆ ครั้งตามที่มีสถานะเป็นไปได้ในทางทฤษฎี

§≔θ籧θη

ลบล้างค่าที่ตัวชี้คำสั่ง

≧⁻§θηη

ลบค่าใหม่ออกจากตัวชี้คำสั่ง การเข้าถึงอาร์เรย์ของ Charcoal เป็นแบบวงกลมดังนั้นนี่จึงเลียนแบบเทปวงกลมของ Foo โดยอัตโนมัติ

»¬§θη

ที่ส่วนท้ายของลูปเอาต์พุตว่าโปรแกรมหยุดทำงานหรือไม่

Stax , 11 ไบต์

Ç₧┬òE▐tµ|⌡1

เรียกใช้และแก้ไขข้อบกพร่อง

มันจะใส่ในรูปแบบของอาร์เรย์จำนวนเต็มโดยมีการ0แสดงหยุด

มันจะออกผล1สำหรับการหยุดชะงักและ0สำหรับเครื่องที่ไม่หยุดนิ่ง

Pyth , 12 ไบต์

!hu.<+_hGtGh

ชุดทดสอบ!

ใช้วิธีการตรงไปข้างหน้า เรียกคืนจนกว่าเราจะเห็นรายการสองครั้งในสถานะที่เหมือนกัน สำหรับโปรแกรมที่หยุดรายการในที่สุดจะมีผู้นำ0เพราะนั่นคือที่หยุดการเรียกซ้ำ สำหรับโปรแกรมที่ไม่หยุดยั้งรายการจะไม่ขึ้นต้นด้วย0แต่จะอยู่ในสถานะที่กระบวนการนั้นจะเป็นระยะดังนั้นเครื่อง Foo จะไม่หยุดทำงาน