29

आइए एक साधारण 2 डी भाषा को परिभाषित करें, जिसे हम अविश्वसनीय रूप से मूल नाम देंगे । Befinge में 5 निर्देश हैं:

<>^v, जैसा कि अधिकांश 2D एसोलैंग्स में, निर्देश सूचक को उनके संबंधित दिशाओं में पुनर्निर्देशित करता है।
. एक सेशन नहीं है

निर्देश पॉइंटर ऊपर-बाएँ कोने से दाएं तरफ शुरू होता है। यदि निर्देश सूचक एक किनारे पर जाता है, तो प्रोग्राम रुक जाता है। प्रत्येक Befinge कार्यक्रम स्पष्ट रूप से या तो रुक जाएगा या एक अनंत लूप में जाएगा जो कुछ भी नहीं करता है। यहाँ दो उदाहरण हैं:

हॉल्टिंग:

>.v
..<

गैर-लंगड़ा:

>....v
..v..<
..>v..
^..<..

ट्यूरिंग-पूर्ण भाषा के लिए रुकने की समस्या हल नहीं है, लेकिन यह इस के लिए है। आपका काम एक कार्यक्रम (या समारोह) है कि एक स्ट्रिंग का प्रतिनिधित्व इनपुट के रूप में लेता है लिखना है befinge कार्यक्रम और एक truthy या falsey मान देता है कि क्या यह हाल्ट या नहीं पर निर्भर करता है।

आप मान सकते हैं कि इनपुट में केवल ये अक्षर होंगे और आयत बनाने के लिए रिक्त स्थान होंगे।
आप निर्देशों के लिए पांच वर्णों के किसी भी सेट का उपयोग कर सकते हैं (जैसे adws )।

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

हॉल्टिंग:

v>
>^

....v....
....>...v
.^..<....
.......v<
.......v.
....^..<.

v<>v>v^
>v^>^>v
<>>^v<v
v^<>v^<

गैर-लंगड़ा:

>..v
^..<

>v<
v<.
>v.
v<.
>.^

>.>.>.v
.><.<.<

यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है।

code-golf interpreter halting-problem

— फल तोड़ना
स्रोत

What (Aheui) के बारे में क्या ?

— जंगवान मिन

कुछ परीक्षण मामले जहां हर तीर नहीं मारा जाता है, अच्छा होगा।

— xnor

ट्यूरिंग ने साबित कर दिया कि हॉल्टिंग समस्या किसी भी ट्यूरिंग-पूर्ण भाषा के लिए हल नहीं है, इसलिए मुझे एक नकली बनाना पड़ा जो ट्यूरिंग पूरा नहीं था। एक भाषा जो हमेशा अंत में रुक जाएगी वह ट्यूरिंग पूरी नहीं है।

— Esolanging फल

1

जहां पथ की तरह एक गैर 90 डिग्री बारी बनाता है हम भी किसी भी उदाहरण नहीं है >..>.या ><।

— xnor

2

@PyRulez क्योंकि मैं चुनौती का हिस्सा बनने के लिए दिशात्मक गति को संसाधित करना चाहता था।

— बजे फल

4

ईएस 6 (जावास्क्रिप्ट), 111, 101 बाइट्स

संपादित करें: 10 और बाइट्स को अधिक से दाढ़ी करने के लिए, वाई और एन के बजाय, आउटपुट मानों को सही और गलत में बदल दिया

golfed

F=(I,M=[...I],c=0,i)=>(i={j:v=I.search`\n`+1,k:-v,h:-1,l:1,q:i,0:0}[M[c]])?F(I,M,c+i+(M[c]=0),i):i!=0

परीक्षा

F=(I,M=[...I],c=0,i)=>(i={j:v=I.search`\n`+1,k:-v,h:-1,l:1,q:i,0:0}[M[c]])?F(I,M,c+i+(M[c]=0),i):i!=0  

//Alphabet Map
tr={
'<':'h',
'>':'l',
'^':'k',
'v':'j',
'.':'q',
'\n':'\n'
};

//Test
T=(I,A)=>{
console.log({"Y":"#Halting","N":"#Non-Halting"}[A]);
console.log("I=\n",I,"\nF(I)=",O=F([...I].map(s=>tr[s]).join('')));
console.log('NY'[O*1] == A ? "OK !" : "NOT OK !");
}

//Halting
T(
`>.v
..<`
,'Y');

//Non-Halting
T(
`>....v
..v..<
..>v..
^..<..`
,'N');

//Halting
T(
`.`
,'Y')

//Halting
T(
`v>
>^`
,'Y');

//Halting
T(
`....v....
....>...v
.^..<....
.......v<
.......v.
....^..<.`
,'Y');

//Halting
T(
`v<>v>v^
>v^>^>v
<>>^v<v
v^<>v^<`
,'Y');

//Non-Halting
T(
`>..v
^..<`
,'N');

//Non-Halting
T(
`>v<
v<.
>v.
v<.
>.^`
,'N');

//Non-Halting
T(
`>.>.>.v
.><.<.<`
,'N');

नमूना आउटपुट

#Halting
I=
>.v
..< 
F(I)= true
OK !    

#Non-Halting
I=
>....v
..v..<
..>v..
^..<.. 
F(I)= false
OK !

#Halting
I=
 . 
F(I)= true
OK !

#Halting
I=
v>
>^ 
F(I)= true
OK !

#Halting
I=
....v....
....>...v
.^..<....
.......v<
.......v.
....^..<. 
F(I)= true
OK !

#Halting
I=
v<>v>v^
>v^>^>v
<>>^v<v
v^<>v^< 
F(I)= true
OK !

#Non-Halting
I=
>..v
^..< 
F(I)= false
OK !

#Non-Halting
I=
>v<
v<.
>v.
v<.
>.^ 
F(I)= false
OK !

#Non-Halting
I=
>.>.>.v
.><.<.< 
F(I)= false
OK !

— टसेपेल्लिन
स्रोत

आप बस का उपयोग नहीं कर सकते हैं Yऔर Nजावास्क्रिप्ट में आउटपुट के रूप में वे दोनों सत्य हैं ।

— ბიმო

3

पायथन 2 , 116 105 बाइट्स

x=1
X=Y=y=0
H=[]
G=input()
while(X,Y,x,y)not in H:H+=[(X,Y,x,y)];C=ord(G[Y][X]);x=C%3-1;y=C%5-1;X+=x;Y+=y

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

चुनौती पुरानी है, लेकिन मुझे लगा कि यह सबसे छोटा अजगर है, मैं इसे पोस्ट करूंगा। इनपुट स्ट्रिंग्स की एक सूची है, लेकिन उपयोग किए गए अक्षर असामान्य हैं।

> G
< B
v C
^ F
. L

उदाहरण के लिए, तीसरा पड़ाव उदाहरण में बदल जाता है ['LLLLCLLLL', 'LLLLGLLLC', 'LFLLBLLLL', 'LLLLLLLCB', 'LLLLLLLCL', 'LLLLFLLBL']। आउटपुट निकास कोड के माध्यम से है, गैर-रोक के लिए 0 (सफलता), और रोकने के लिए 1 (त्रुटि)। किसी भी सुझाव या चाल की सराहना की।

— nedla2004
स्रोत

2

बेफुंज -98 (पायफंज) , 217 209 200 बाइट्स

#v10dpf1dp12dp3dpk
 >#v~:a-#v_$10dp1dg1+1dp >
v  >10dp;>0dg1dgp0dg1+0dp^;f1dp
>0dg1dgg:'^-#v_n1-v
^<v01_v#!->':<
  <   >:'<-#v_01-0>   v
v^pd1+gd3gd1[:'v-#v_01>3dp2dpndg1dgp
>0dg2dg+0dp ^ @.!;>:'.-#;_

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

एक befinge पड़ाव समस्या एक befunge समाधान की जरूरत है। सच्चाई के लिए 0 और झूठी के लिए 1 रिटर्न देता है। 1,15 से शुरू होने वाले ग्रिड पर इनपुट डालता है और फिर शीर्ष पर चलता है, शून्य के साथ तीर की जगह। जैसे ही हमने एक शून्य मारा, हम जानते हैं कि यह लूप है। इसके अलावा कुछ भी> <^ v। और शून्य को प्रोग्राम को रोकने के लिए विचार किया जाता है, जिसमें रिक्त स्थान की सीमा को शामिल किया जाता है जिसे हम ग्रिड पर थोड़ा ऑफसेट करके कार्यक्रम के चारों ओर प्राप्त करते हैं।

कुछ काटने के लिए दाढ़ी रखने का एक आसान तरीका यह होगा कि इसके बजाय संख्या का उपयोग किया जाए। लेकिन मुझे ऐसा नहीं लगता कि यह इसके लायक है।

— डेविड
स्रोत

A befinge halting problem needs a befunge solution.ठीक। +1

— Draco18s

1

टर्टल , 146 बाइट्स

!u[*.[ r+.]l[ l]dr_+]#*#[ u]d[ (.r)(>.r{.r}@>)(v.d{.d}@v)(<.l{.l}@<)(^.u{.u}@^)(*@0' )],@1(0@0)(v' d)(<' r)(>' l)(^' d)[ u]d[ l]r[ [ r]l[ ' l]dr],

इस कार्यक्रम में I / O को अलग तरह से लिया गया है: कृपया प्रत्येक पंक्ति को अंतिम एक सहित एक स्थान के साथ समाप्त करें। Turtlèd को newlines पसंद नहीं है, क्योंकि यह पात्रों के दूसरे आयाम के लिए एक ग्रिड का उपयोग करता है।

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

हमेशा के लिए छोरों के लिए 0, हाल्ट के लिए 1।

सामान्य स्पष्टीकरण:

यह ग्रिड पर इनपुट लिखता है, फिर यह वास्तव में पथ का निर्माण करता है जो कि ग्रिड के चारों ओर बनाते हैं, प्रत्येक तीर को एक * के रूप में प्रतिस्थापित करता है, यह भी चर संस्करण में दिशा को बचाता है। यदि यह एक *, एक तीर से पहले टकराता है, तो कार्यक्रम रुक नहीं जाएगा, इसलिए यह 0लूप से बाहर निकलने के लिए चार्ट को सेट करता है। अन्यथा, यह ग्रिड के अंत से टकराएगा और लूप से बाहर निकल जाएगा। यह चर संस्करण लिखेंगे। यदि यह ग्रिड के अंत से टकराता है, तो यह ग्रिड के लिए वापस जाने के लिए चार संस्करण में संग्रहीत दिशा का उपयोग करता है, और रुके के लिए चार्ट को सेट करता है 1। यदि वास्तव में चर संस्करण 0 था, तो दिशा नहीं, इसे वापस लाने की आवश्यकता नहीं है, क्योंकि यह अभी भी है, और यह इसे वापस सेट करता है 0। यह ग्रिड को बंद कर देता है, फिर पड़ावों के लिए चार वर लिखता 1है 0।

— विनाशकारी नींबू
स्रोत

1

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

f=(a,v=1,x=0,[t,...u]=a,n=1+a.search`
`,c=a[x])=>t?f(a,v=+c?c-2||v:c+n,x-v,u):!c

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

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

f=(a,v=1,x=0,[t,...u]=a,n=1+a.search`
`,c=a[x])=>t?c>' '<=f(a,v=+c?c-2||v:c+n,x-v,u):0

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

— l4m2
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 158 127 बाइट्स

f=(a,x=0,y=0,d=1,e=0,c=a[y]&&a[y][x])=>c<'~'?(c>'.'&&(a[y][x]='~',d=(c=='>')-(c=='<'),e=(c=='v')-(c=='^')),f(a,x+d,y+e,d,e)):!c

एक दो-आयामी चरित्र सरणी के रूप में इनपुट लेता है और रुकने के trueलिए और falseएक अनंत लूप के लिए लौटता है । ~आवर्ती दिशा वर्णों की स्थापना करके काम करता है क्योंकि यह उन्हें पुन: बनाता है। संपादित करें: आवर्ती करने से पहले मेरी दिशा वेक्टर को अपडेट करके 31 बाइट्स सहेजे गए।

निर्देश वर्णों का दुरुपयोग ( 1=^ 4=< 5=. 6=> 9=v) मुझे 101 बाइट्स तक ले जाता है:

f=(a,x=0,y=0,d=1,e=0,c=a[y]&&a[y][x])=>+c?(c-5&&(a[y][x]='0',d=~-c%4,e=~-(c>>2)),f(a,x+d,y+e,d,e)):!c

— नील
स्रोत

> इनपुट को द्वि-आयामी चरित्र सरणी के रूप में लेता है क्या एक अलग स्वरूपित इनपुट की अनुमति है? (एक फ्लैट स्ट्रिंग से एक सरणी में जा रहे हैं बाइट्स भी लेते हैं)।

— टसेपेल्लिन

@zeppelin मेरा विश्वास है कि यह अनुमति है। उदाहरण के लिए meta.codegolf.stackexchange.com/q/2214/17602 देखें ।

— नील

संदर्भ: एफ परिभाषित नहीं है

— l4m2

@ l4m2 बाह, मैंने इसे फिर से किया है, मैंने f=बाइट की गिनती में शामिल किया है लेकिन कोड नहीं ...

— नील

1

स्माइलबासिक, 158 145 बाइट्स

यदि एक ही तीर एक से अधिक बार सामना किया जाता है, तो कार्यक्रम कभी भी बंद नहीं होगा। जब निर्देश पॉइंटर एक तीर से गुजरता है, तो इसे एक अलग प्रतीक के साथ बदल दिया जाता है, जिसके कारण फ़ंक्शन 0 पर वापस लौटता है यदि यह फिर से पहुंच जाता है। यदि IP सीमा से बाहर चला जाता है, तो यह 1 लौटता है।

DEF H P@L
C=VAL(P[Y][X])IF C>8THEN?0RETURN
IF C THEN D=C-1P[Y][X]="9
X=X+!D-(D==1)Y=Y+(D==2)-(D>2)IF X+1&&Y+1&&Y-LEN(P)&&X-LEN(P[0])GOTO@L
?1
END

स्ट्रिंग के एक सरणी के रूप में इनपुट लेता है। <any non-digit chracter>, 1, 2, 3, 4= ., >, <, v,^

— 12Me21
स्रोत

0

पायथन 2, 182 बाइट्स

m,v,d,x,y=input(),[],'>',0,0
try:
 while 1:
  if[x,y]in v:print 0;break
  c=m[y][x]
  if c!='.':d=c;v+=[[x,y]]
  if d in'><':x+=[-1,1][d=='>']
  else:y+=[-1,1][d=='v']
except:print 1

इनपुट के रूप में एक स्ट्रिंग सरणी लेता है। मुझे यह और अधिक करना है लेकिन अभी चुनाव का समय है।

Ungolfed:

input = input()

visited = [  ] 

dir = ">"
x=0
y=0

try:
    while True:
        if[x,y]in visited:print False;break
        char=input[y][x]
        if char!=".":
            dir=char
            visited+=[[x,y]]

        if dir==">":
            x+=1
        if dir=="<":
            x-=1
        if dir=="v":
            y+=1
        if dir=="^":
            x-=1
except:
    print True

— डैनियल
स्रोत

हे, क्या होगा अगर आपने कोशिश से मुख्य भाग निकाल लिया, और केवल एक कोशिश में और सिवाय c = m [y] [x] डाल दिया? यह आपको 1/0 के साथ ब्रेक को बदलने की अनुमति देगा, साथ ही साथ इंडेंट को कम करेगा।

— विनाशकारी नींबू

1

[-1,1][d=='v'] -> 2*(d>'>')-1और [-1,1][d=='>'] -> 2*(d>'<')-1कुल 6 बाइट्स बचाएं।

— केड

के लिए गलत जवाब["<>"]

— feersum

0

क्लोजर, 143 बाइट्स

#((fn[p v i s](if-let[v({\> 1\< -1\^(- s)\. v\v s}(get % p))](if(neg? i)1(recur(+ p v)v(dec i)s))))0 1 1e9(+(count(take-while(set"<>v^.")%))1))

4 राज्य तर्क के साथ एक फ़ंक्शन: स्थिति p, वेग v, चरण सूचकांक iऔर एक पंक्ति का आकार s। 1यदि हम 10 ^ 9 चरणों और nilअन्यथा में सीमा से बाहर नहीं गए तो वापस लौटता है । वास्तव में, सुनिश्चित करने के लिए हमें कितने चरणों की आवश्यकता है (count %)? मुझे लगता है कि यह उससे कहीं अधिक है क्योंकि समान एनओपी को क्षैतिज और लंबवत रूप से ट्रेस किया जा सकता है।

इस तरह कहा जा सकता है (तर्क, के रूप में सामान्य तार लेता getरिटर्न nilजब सीमा से बाहर):

(def f #( ... ))
(f ">....v\n..v..<\n..>v..\n^..<..")
(f "v>\n>^")
(f "....v....\n....>...v\n.^..<....\n.......v<\n.......v.\n....^..<.")

राज्य संक्रमण (+1, -1, + एस,) शब्दकोश में एन्कोडेड हैं {\> 1\< -1\^(- s)\. v\v s}।

— NikoNyrh
स्रोत

ग्रिड वर्णों की संख्या का 4 गुना पर्याप्त होना चाहिए: यदि सूचक उसी आवक दिशा के साथ एक ही वर्ण पर वापस आता है, तो यह एक अनंत लूप में है।

— ग्रेग मार्टिन

0

पायथन 2/3, 201 192 बाइट्स

def f(x):
 X=Y=b=0;a=1;D={}
 while len(x)>Y>-1<X<len(x[Y]):
  try:
   a,b={'>':(1,0),'^':(0,-1),'<':(-1,0),'v':(0,1)}[x[Y][X]]
   if(X,Y)in D:return 0
  except:0
  D[X,Y]=0;X+=a;Y+=b
 return 1

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

के लिए सही उत्तर देता है ["<>"]

— ceilingcat
स्रोत

मेरा मानना है कि आप एक फ़ंक्शन से पूर्ण कार्यक्रम में बदलकर कई बाइट्स बचा सकते हैं। आप बदल सकते हैं def f(x):के साथ x=input()0 बाइट अंतर के साथ है, तो, अतिरिक्त खरोज (-8 बाइट्स) को हटा दें तो की जगह return xके साथ exit(x)(प्रति अनुमति मेटा आम सहमति ,) एक और 2 बाइट्स के लिए। वैसे भी, अच्छा समाधान!

— उभयचर जूल

0

जावा, 477

मुझे पता है कि यह नहीं जीत रहा है, n = और शायद अधिक गोल्फ हो सकता है, लेकिन यह एक समान पद्धति का उपयोग करता है जैसे कि अन्य उत्तर क्या उपयोग करते हैं, लेकिन यह लुकअप करने के लिए हैशमैप का उपयोग करता है। इनपुट प्रतीकों का उपयोग कर रहा है> <^ v और इसके अलावा कुछ भी नहीं सेशन के लिए। इनपुट args के माध्यम से आता है।

golfed

import java.util.*;interface B{static void main(String[]a){HashMap<String,Byte>h=new HashMap<>();int x,y=0;for(String s:a){x=0;for(char c:s.toCharArray()){if("><^v".indexOf(c)>-1)h.put(x+","+y,(byte)c);x++;}y++;}x=0;y=0;int d=0;int D=0;while(x>-1&&x<a[0].length()&&y<a.length&&y>-1){Byte v=h.get(x+","+y);if(v!=null){if(v==0){System.out.print(0);return;}d=(v<85)?"<>".indexOf(v)*2-1:0;D=(v>84)?"^v".indexOf(v)*2-1:0;}h.replace(x+","+y,(byte)0);x+=d;y+=D;}System.out.print(1);}}

UNGOLFED

आयात java.util। *;

interface B{
    static void main(String a[]) {
        HashMap<String, Byte> h = new HashMap<>();
        int x, y = 0;
        for(String s : a) {
            x = 0;
            for(char c : s.toCharArray()) {
                if ("><^v".indexOf(c) > -1) h.put(x + "," + y, (byte) c);
                x++;
            }
            y++;
        }
        x = 0;
        y = 0;
        int d = 0;
        int D = 0;
        while(x > -1 && x < a[0].length() && y < a.length && y > -1) {
            Byte v = h.get(x + "," + y);
            if(v != null) {
                if(v == 0) {System.out.print(0); return;}
                d = (v < 85) ? "<>".indexOf(v)*2-1 : 0;
                D = (v > 84) ? "^v".indexOf(v)*2-1 : 0;
            }
            h.replace(x + "," + y, (byte) 0);
            x += d;
            y += D;
        }
        System.out.print(1);
    }
}

स्पष्टीकरण जल्द ही आ रहा है!

— KrystosTheOverlord
स्रोत

एक छोटी सी बात: आप अंतरिक्ष String a[]को बदल सकते हैं String[]aऔर छोड़ सकते हैं ।

— बजे फल

आप भी उपयोग कर सकते हैं varयदि आप जावा 10. का उपयोग करते हैं, तो आप बहुत सारे स्थानों पर हैं

— फल

410 बाइट्स

— छत

Befinge के लिए Halting Problem को हल करें

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

हॉल्टिंग:

गैर-लंगड़ा:

ईएस 6 (जावास्क्रिप्ट), 111, 101 बाइट्स

पायथन 2 , 116 105 बाइट्स

बेफुंज -98 (पायफंज) , 217 209 200 बाइट्स

टर्टल , 146 बाइट्स

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

सामान्य स्पष्टीकरण:

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

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

जावास्क्रिप्ट (ईएस 6), 158 127 बाइट्स

स्माइलबासिक, 158 145 बाइट्स

पायथन 2, 182 बाइट्स

क्लोजर, 143 बाइट्स

पायथन 2/3, 201 192 बाइट्स

जावा, 477