43

यह निर्धारित करना कि ट्यूरिंग मशीन हाल्ट को अच्छी तरह से जाना जाता है या नहीं, लेकिन यह सरल मशीनों के लिए जरूरी नहीं है।

एक फू मशीन एक परिमित टेप, जहां टेप पर प्रत्येक कोशिका एक पूर्णांक या पड़ाव प्रतीक होता है के साथ एक मशीन है h, जैसे

2 h 1 -1

पहली सेल की ओर इशारा करके निर्देश सूचक शुरू होता है:

2 h 1 -1
^

प्रत्येक चरण पर, निर्देश सूचक उस संख्या से आगे बढ़ता है जिस पर वह इंगित करता है, फिर उस संख्या को नकारता है। इसलिए, एक कदम के बाद, यह आगे की 2कोशिकाओं को स्थानांतरित करेगा , और 2एक में बदल जाएगा -2:

-2 h 1 -1
     ^

फू मशीन तब तक ऐसा करती रहती है जब तक कि निर्देश सूचक हॉल्ट प्रतीक ( 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
  ^

इन फू मशीनों के बारे में एक दिलचस्प बात यह है कि कुछ पड़ाव नहीं करते हैं, जैसे:

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

यह कार्यक्रम उन अंतिम चार राज्यों में हमेशा के लिए बंद रहेगा।

तो, एक प्रोग्राम लिखें जो निर्धारित करता है कि कोई फू मशीन रुकती है या नहीं! आप फू मशीनों के लिए किसी भी (उचित) इनपुट प्रारूप का उपयोग कर सकते हैं, और आप 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

code-golf halting-problem

— लियो तेनाबाम
स्रोत

5

बस इसलिए मुझे यकीन है, इसे हल करने के लिए एल्गोरिथ्म के बारे में। मैं एक एल्गोरिथ्म मास्टर नहीं हूं, इसलिए मैं गलत दिशा में जाने से पहले पूछना पसंद करता हूं। क्या एक नॉन-हॉल्टिंग फू मशीन हमेशा अपने सटीक मूल स्थिति में वापस आ जाएगी? या क्या "अराजक-व्यवहार" गैर-हॉल्टिंग मशीनें हैं?

— वी। कोर्टोइस

5

@ V.Courtois सभी नॉन-हॉल्टिंग फू मशीनें राज्यों की एक लूप में समाप्त हो जाएंगी, क्योंकि केवल बहुत ही संभव रूप से कई संभावित राज्यों में एक फू मशीन हो सकती है (निर्देश पॉइंटर हो सकता है और n ^ स्थानों पर संभव है, और 2 ^ संभव टेप विन्यास)। प्रत्येक राज्य में एक और केवल एक "अगला राज्य" होता है। इसलिए, अगर कोई फू मशीन वापस उसी अवस्था में खत्म हो जाती है, जिसमें वह पहले से ही है, तो वह सिर्फ लूपिंग रखेगी। क्योंकि केवल बहुत से राज्य हैं, यह राज्यों के बीच घूम-घूम कर नहीं रख सकता है क्योंकि यह अंत में पहले से ही एक होने जा रहा है।

— लियो तेनेबाम

3

सुझाए गए परीक्षण का मामला: 1 2 h 42(रोक नहीं करता है)

— Arnauld

6

सुझाए गए परीक्षण का मामला: 3 2 1 1 4 h। यह एक बार रुक जाता है लेकिन तत्वों की संख्या के दोगुने से अधिक पुनरावृत्तियों की आवश्यकता होती है।

— अरनुलद

10

सुझाए गए लंबे-लंबे परीक्षण मामले:,

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

जो 786430 चरणों के बाद रुकता है।

— मैग्मा

11

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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ब्लॉक में लपेटा जाना होता है, लेकिन यहां वैसे भी है:

सी # (.NET कोर) , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह फ़ंक्शन एक इंट * में लेता है और एक एक्शन देता है; दूसरे शब्दों में, यह एक रूखा कार्य है। केवल यही कारण है कि मैं पॉइंटर्स का उपयोग करता हूं क्योंकि codegolf.meta.stackexchange.com/a/13262/84206 है, जो मुझे पहले से ही सरणी की लंबाई के साथ परिभाषित एक चर होने से बाइट्स को बचाने की अनुमति देता है।

सहेजे गए 9 बाइट्स @someone की बदौलत

— अज्ञान का अवतार
स्रोत

अपने कोड को 2 बाइट्स से जोड़ा

— IQuick 143

@ IQuick143 अच्छा पकड़, धन्यवाद

— अज्ञानता

मुझे यकीन है कि अगर कोई बढ़त जिन मामलों के लिए यह काम नहीं करेगा कर रहे हैं नहीं कर रहा हूँ, लेकिन वर्तमान परीक्षण मामलों में से किसी को तोड़ने के बिना आप बदल सकते 1<<fके साथ 2*fएक बाइट को बचाने के लिए।

— केविन क्रूज़सेन

1

77 LINtes भयानक LINQ जादू और Arnauld के फिक्स के साथ । मुझे नहीं पता कि यह समाधान कैसे काम करता है, इसलिए मैंने इसे तोड़ा हो सकता है।

— कोई

1

सामान्य बाइट 1-बाइट गोल्फ के माध्यम से 63 बाइट्स और IO को एरर / नो एरर में बदलना। लिंक से लिंक करें

— कोई

7

पायथन 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

इसे ऑनलाइन आज़माएं!

पायथन 2 के लिए भी काम करता है; बाइट को पायथन 2 में प्रिंट के साथ रिटर्न की जगह और फंक्शन प्रिंट को वापस करने के बजाय स्टडआउट करने से बचाया जा सकता है। R रुकने के Trueलिए और Falseगैर-रुकने के लिए मुड़ता है ।

@Neil और @Arnauld को ध्यान देने के लिए धन्यवाद कि मुझे रुकने के लिए अधिक समय तक जांच करने की आवश्यकता थी। @ समस्या के साथ समस्या के लिए @Jitse को धन्यवाद [2,0]। टेप मानों की निरपेक्षता टेप लंबाई से अधिक हो सकती है, इसके लिए @mypetlion को धन्यवाद।

— निक केनेडी
स्रोत

5

ठीक है, मैं काट लूंगा: आप कैसे जानते हैं x+xकि पर्याप्त है?

— नील

4

@ नील यह वास्तव में पर्याप्त नहीं है। एक प्रति-उदाहरण है [ 3, 2, 1, 1, 4, 0 ], जो 12 से अधिक पुनरावृत्तियों को रोक देता है।

— अरनुलद

1

@ जीत से len(x)*xकाम नहीं चलेगा । उदाहरण के लिए,[8,7,6,5,7,4,0,3,6] से अधिक पुनरावृत्तियों में पड़ाव ।

9^{2}

$9^2$

— अरनुलद

2

2**len(x)अभी भी अधिकतम से थोड़ा कम नहीं है ? मैं n*(2**n)(के साथ n=len(x)-1) राज्यों की संख्या की गणना करता हूं ।

— 15

1

@Oobalance मैं देख रहा हूं कि आपका क्या मतलब है, क्योंकि प्रत्येक राज्य में प्रत्येक सेल में एक पॉइंटर हो सकता है ... हालांकि, मुझे लगता है कि इस तथ्य से कुछ अन्य सीमा लागू होती है कि प्रत्येक सेल केवल दो अन्य कोशिकाओं में संक्रमण कर सकता है। एक तरफ ध्यान दें के रूप में: चुनौती में कुछ भी नहीं कहना है वहाँ है इनपुट में एक हॉल्टिंग राज्य होने के लिए

— जो राजा

6

जेली , 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

— निक केनेडी
स्रोत

सभी प्रविष्टियों को घुमाकर और फिर पहला परिणाम रखते हुए एक बाइट को बचाएं:N1¦ṙ⁸ḢƊÐLḢẸ

— जोनाथन एलन

5

पायथन 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 बाइट्स जोकिंग और जितसे को धन्यवाद

— HyperNeutrino
स्रोत

@JoKing 109 बाइट्स पहली लाइन में वेरिएबल असाइनमेंट करते हुए।

— जित्स

92 बाइट्स में टापल रूपांतरण को तारांकित विस्तार में बदलकर, एक खाली सेट के साथ शुरू नहीं करना और whileस्थिति को फिर से परिभाषित करना ।

— जितासे

@JoKing लानत, मैं कभी नहीं सीखता: पी। 93 बाइट्स तब।

— जित्स

91 बाइट्स

— 15

@JoKing धन्यवाद!

— हाइपरएन्यूट्रीनो

5

पर्ल 6 , 46 43 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

0यदि मशीन रुकती है तो हॉल्ट द्वारा रुकावटों का सामना करना पड़ता है और सच हो जाता है। यह तर्क 2**(length n)समय को दोहराता है , जहां अगर पॉइंटर हॉल्ट सेल पर समाप्त होता है, तो यह वहां रहता है, अन्यथा यह एक गैर-हॉल्ट सेल पर होगा। यह काम करता है क्योंकि 2**nफू मशीन में होने के लिए केवल संभावित राज्य (पड़ाव कोशिकाओं की अनदेखी) होते हैं, क्योंकि प्रत्येक गैर-हॉल्ट सेल में केवल दो राज्य होते हैं। ठीक है हाँ, वहाँ की तुलना में राज्य हैं, लेकिन संकेत (और इसलिए राज्यों) के बीच सीमित संभावित संक्रमणों के कारण 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

— मजाक कर रहा है
स्रोत

2

फू मशीन की स्थिति में सूचक का स्थान भी शामिल है, न कि प्रत्येक कोशिका के संकेत।

— मैग्मा

1

टेप a_1 ... a_n 0 के साथ फू मशीन के लिए एक सबूत का स्केच। कोने (= राज्यों) के बीच निर्देशित किनारों (= Foo का एक पुनरावृत्ति) के साथ प्रत्येक कोशिका के संकेतों के एन-क्यूब पर विचार करें, किनारों के किसी भी लूप के माध्यम से एक ही शीर्ष पर जाने से आईपी उसी स्थिति में होगा जिसके साथ यह शुरू हुआ था । प्रमाण: एक लूप में, आईपी प्रत्येक आयाम में एक समान संख्या में यात्रा करता है, अर्थात k × (a_j + (-a_j)) द्वारा प्रत्येक आयाम के लिए% n for 0, इसलिए यह हमेशा एक ही स्थिति में लौटता है, केवल प्रत्येक शीर्ष के लिए n राज्यों में से 1 राज्य को देख रहा है, अर्थात 2 ^ n राज्यों की कुल अधिकतम (= घन की संख्या)।

— १itix:५४ पर कृति लिथोस

n

$n$

⌊ 2^{n} . l o g (n) / n ⌉

$\lfloor2^n.log(n)/n\rceil$

3

05AB1E , 14 13 बाइट्स

goFć©(š®._}®_

इसे ऑनलाइन आज़माएं!

इनपुट को पूर्णांक निर्देश के रूप में पूर्णांकों की सूची के रूप में लेता है। रुकने के लिए 1 और वापसी न करने के लिए 0 देता है।

2 बाइट बचाने के लिए @KevinCruijssen को धन्यवाद!

— निक केनेडी
स्रोत

ओह अच्छा, तो यह है कि आपके जेली जवाब क्या है! घुमाएँ और का महान उपयोग ć! मैं अपने जवाब को गोल करने की उम्मीद में स्पष्टीकरण की प्रतीक्षा कर रहा था, लेकिन आपने मुझे इसे हरा दिया। , पी -1 मेरा उत्तर के रूप में ही गोल्फ कर यद्यपि द्वारा बाइट: g·Fकरने के लिए «v( यह ऑनलाइन की कोशिश करें। )

— केविन Cruijssen

और इसके ©®बजाय का उपयोग करके एक अतिरिक्त -1 DŠs: «vć©(š®._}®_( यह ऑनलाइन प्रयास करें। )

— केविन क्रूज़सेन

जैसा कि अर्नुल्ड ने आपके पायथन उत्तर पर उल्लेख किया है, दो बार लूपिंग करना पर्याप्त नहीं है। तो आप बदल सकते हैं «vकरने के लिए goF।

— केविन क्रूज़सेन

@ केविनक्रूजसेन धन्यवाद

— निक केनेडी

3

जावा 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

— केविन क्रूज़सेन
स्रोत

2

बस सोच रहे हैं, क्या आपको एक अतिरिक्त तर्क के रूप में लंबाई लेने की अनुमति है? मेटा पर आईओ पद के लिए डिफ़ॉल्ट इतना कहना नहीं है, और एकमात्र कारण मेरी दूसरी जवाब लंबाई लेता है, क्योंकि यह एक में ले जाता है int*(से codegolf.meta.stackexchange.com/a/13262/84206 )

— अज्ञान की अवतार

@EododimentofIgnorance आह, जब मैंने आपका उत्तर देखा तो मैंने मान लिया कि किसी प्रकार का मेटा नियम है जो लंबाई को अतिरिक्त इनपुट के रूप में लेने की अनुमति देता है, लेकिन यह केवल संकेत पर लागू होता है। मुझे बताने के लिए धन्यवाद। मैंने लंबाई पैरामीटर हटा दिया है (लेकिन फिर भी परिणाम निर्धारित करने के लिए त्रुटि / नो-एरर का उपयोग करें)।

— केविन क्रूज़सेन

3

हास्केल , 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एक हॉल्टिंग राज्य का प्रतिनिधित्व करने के साथ ।

8.4 से अधिक जीएचसी का एक संस्करण मानता है (फरवरी 2018 को जारी किया गया)।

— बी मेहता ने
स्रोत

2

जावास्क्रिप्ट (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 उत्तर के समान ही है

4 बाइट के लिए धन्यवाद बचाने @Arnaud

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट (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जब मशीन रुकता है और मशीन के रुकने पर चुपचाप समाप्त हो जाता है तो फेंकता है ।

इसे ऑनलाइन आज़माएं!

— IQuick 143
स्रोत

1

स्काला , 156 बाइट्स

अभी भी गोल्फ IMO, लेकिन मैं अभी इसके लिए ठीक हूं। रिटर्न 0गैर हॉल्टिंग के लिए Fooऔर 1हॉल्टिंग के लिए Fooहै। इनपुट 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 सेकंड), इसके अलावा प्रतियां बनाता है ... लेकिन आप अभी भी इसे ऑनलाइन आज़मा सकते हैं।

— वी। कोर्टीस
स्रोत

1

पर्ल 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]

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

1

अटैची , 40 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

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

यह फू मशीन का एक एकल पुनरावृत्ति करता है; यह पहले सदस्य की उपेक्षा करता है, फिर सरणी के पहले तत्व (मूल, गैर-नकारात्मक) द्वारा सरणी को घुमाता है।

Periodicडुप्लिकेट परिणाम जमा होने तक इस फ़ंक्शन को लागू करेगा। एक मशीन या तो रुक जाती है, या एक तुच्छ अनंत लूप में चली जाती है। यदि यह रुक जाता है, तो पहला तत्व 0. होगा अन्यथा, यह गैर-शून्य होगा।

&Nएक संख्यात्मक सरणी का पहला तत्व प्राप्त करने का एक गोल्फ का तरीका है। फिर, 0 (हॉल्टिंग मशीन) और कुछ और (नॉन हॉल्टिंग मशीन) के लिए Notरिटर्न ।truefalse

— कोनोर ओ ब्रायन
स्रोत

1

चारकोल , 28 बाइट्स

≔⁰ηＦＸ²Ｌθ«§≔θη±§θη≧⁻§θηη»¬§θη

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चारकोल के डिफ़ॉल्ट बूलियन आउटपुट का उपयोग करके आउटपुट, जो कि -सही के लिए है और झूठे के लिए कुछ भी नहीं है। स्पष्टीकरण:

≔⁰η

निर्देश सूचक को प्रारंभ करें।

ＦＸ²Ｌθ«

सैद्धांतिक रूप से संभव राज्यों के रूप में कई बार लूप।

§≔θη±§θη

निर्देश सूचक पर मान हटाएं।

≧⁻§θηη

अनुदेश सूचक से नया मान घटाएँ। चारकोल की सरणी एक्सेस चक्रीय हैं, इसलिए यह फू के परिपत्र टेप का स्वचालित रूप से अनुकरण करता है।

»¬§θη

लूप के अंत में, आउटपुट कि क्या कार्यक्रम रुका है।

— नील
स्रोत

0

स्टैक्स , 11 बाइट्स

Ç₧┬òE▐tµ|⌡1

इसे चलाएं और डीबग करें

यह एक पूर्णांक सरणी के रूप में इनपुट लेता है, जिसमें 0ठहराव का प्रतिनिधित्व होता है।

यह हॉल्टिंग के 1लिए और 0नॉन-हॉल्टिंग मशीन के लिए आउटपुट देता है ।

— पुनरावर्ती
स्रोत

0

पायथ , 12 बाइट्स

!hu.<+_hGtGh

परीक्षण सूट!

सीधे-अग्रगामी दृष्टिकोण का उपयोग करता है। जब तक हम सूची को एक समान स्थिति में दो बार नहीं देख लेते तब तक पुन: प्राप्त करें। रुकने वाले कार्यक्रमों के लिए, सूची में अंततः एक अग्रणी होगा, 0क्योंकि जहां पुनरावृत्ति रुक जाती है। उन कार्यक्रमों के लिए जो रुकना नहीं चाहते हैं, सूची के साथ शुरू नहीं होगा 0, बल्कि ऐसी स्थिति में होगा जहां से प्रक्रिया आवधिक होगी और इसलिए फू मशीन बंद नहीं होगी।

— श्री एक्सकोडर
स्रोत

क्या यह फू मशीन रुकती है?

परीक्षण के मामलों

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 71 बाइट्स

सी # (.NET कोर) , 64 बाइट्स

पायथन 3 , 63 89 बाइट्स

जेली , 15 11 बाइट्स

व्याख्या

पायथन 3 , 91 बाइट्स

पर्ल 6 , 46 43 36 बाइट्स

व्याख्या

05AB1E , 14 13 बाइट्स

जावा 8, 78 79 73 बाइट्स

हास्केल , 79 बाइट्स

जावास्क्रिप्ट (Node.js) , 71 67 बाइट्स

जावास्क्रिप्ट (Node.js) , 61 बाइट्स

स्काला , 156 बाइट्स

पर्ल 5 -ap , 88 बाइट्स

अटैची , 40 बाइट्स

व्याख्या

चारकोल , 28 बाइट्स

स्टैक्स , 11 बाइट्स

पायथ , 12 बाइट्स

पर्ल 5 `-ap` , 88 बाइट्स