हर पड़ाव कार्यक्रम को आउटपुट करें (एक समानांतर दुभाषिया लिखें)


26

इस चुनौती का लक्ष्य (अंततः) अपनी पसंद की भाषा में हर संभव पड़ाव कार्यक्रम का उत्पादन करना है। सबसे पहले यह असंभव लग सकता है, लेकिन आप इसे निष्पादन आदेश के बहुत सावधानी से विकल्प के साथ पूरा कर सकते हैं।

नीचे यह बताने के लिए एक ASCII चित्र है। कॉलम हर संभावित प्रोग्राम की संख्या का प्रतिनिधित्व करते हैं (प्रत्येक प्रोग्राम एक सीमित वर्णमाला से प्रतीकों की एक सीमित संख्या है)। प्रत्येक पंक्ति को उस कार्यक्रम के निष्पादन में एक विलक्षण कदम का प्रतिनिधित्व करते हैं। एक Xनिष्पादन उस समय-कदम पर है कि कार्यक्रम द्वारा किया जाता प्रतिनिधित्व करते हैं।

 step#  p1 p2 p3 p4 p5 p6
     1  X  X  X  X  X  X
     2  X  X  X  X  X  
     3  X  X     X  X
     4  X  X     X  X
     5  X  X     X
     6     X     X
     7     X     X
     8     X     X
     9     X     X
     ∞     X     X

जैसा कि आप बता सकते हैं, प्रोग्राम 2 और 4 रुकते नहीं हैं। यदि आप उन्हें एक-एक-समय पर निष्पादित करते हैं, तो आपका नियंत्रक अनंत लूप में फंस जाएगा जो कि प्रोग्राम 2 है और कभी भी आउटपुट प्रोग्राम 3 और उससे आगे नहीं होगा।

इसके बजाय, आप एक dovetailing दृष्टिकोण का उपयोग करें । पत्र पहले 26 चरणों के लिए निष्पादन के संभावित आदेश का प्रतिनिधित्व करते हैं। *रों स्थानों पर जहां कि इस कार्यक्रम को रोक दिया है और outputted है कर रहे हैं। .रों चरण हैं, जो अभी तक क्रियान्वित नहीं किया गया है।

 step#  p1 p2 p3 p4 p5 p6
     1  A  C  F  J  N  R  V
     2  B  E  I  M  Q  *  Z
     3  D  H  *  P  U
     4  G  L     T  Y
     5  K  O     X
     6  *  S     .
     7     W     .
     8     .     .
     9     .     .
     ∞     .     .

लक्ष्य भाषा के लिए आवश्यकताएँ

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

एक उदाहरण के रूप में, यदि आप ब्रेनफैक का परीक्षण करना चुनते हैं, तो यह सबसे अच्छा है कि आप []-+<>सबसेट का परीक्षण करें , क्योंकि इनपुट समर्थित नहीं है और आउटपुट को केवल फेंक दिया गया है (नीचे देखें)।

जब "कंट्रोलर" प्रोग्राम (जिसे आप गोल्फ कर रहे हैं) की बात आती है, तो कोई विशेष आवश्यकता नहीं है। सामान्य भाषा प्रतिबंध लागू होते हैं।

कार्यक्रमों की एक अनंत सूची कैसे बनाएं

अधिकांश प्रोग्रामिंग भाषाओं को एक परिमित वर्णमाला से प्रतीकों की एक श्रृंखला के रूप में दर्शाया जा सकता है। इस मामले में, बढ़ती लंबाई के क्रम में हर संभव कार्यक्रम की सूची को एन्यूमरेट करना अपेक्षाकृत आसान है। आपके द्वारा उपयोग की जाने वाली वर्णमाला लक्ष्य भाषा की आवश्यकताओं का प्रतिनिधि होना चाहिए । ज्यादातर मामलों में, यह मुद्रण योग्य ASCII है। यदि आपकी भाषा एक अतिरिक्त सुविधा के रूप में यूनिकोड का समर्थन करती है, तो आपको यूनिकोड वर्णों के हर संभव संयोजन का परीक्षण नहीं करना चाहिए, बस ASCII। यदि आपकी भाषा केवल उपयोग करती है, []-+<>तो ASCII वर्ण "टिप्पणी" के विभिन्न संयोजनों का परीक्षण न करें। APL जैसी भाषाओं के अपने विशेष अक्षर होंगे।

यदि आपकी भाषा को कुछ गैर-वर्णनात्मक तरीके से वर्णित किया गया है, जैसे कि फ्रैक्ट्रन या ट्यूरिंग मशीन, तो सभी संभव वैध कार्यक्रमों की सूची बनाने के अन्य समान रूप से मान्य तरीके हैं।

कार्यक्रमों की बढ़ती सूची की व्याख्या करना

इस चुनौती का प्रमुख हिस्सा कार्यक्रमों की बढ़ती सूची के लिए एक समानांतर दुभाषिया लिखना है। इसके लिए कुछ बुनियादी कदम हैं:

  • सूची में कार्यक्रमों की एक सीमित संख्या जोड़ें
  • सूची पर प्रत्येक कार्यक्रम को व्यक्तिगत रूप से समय की एक सीमित अवधि के लिए व्याख्या करें। यह प्रत्येक के लिए एक निर्देश चरण प्रदर्शन करके पूरा किया जा सकता है। सभी राज्यों को बचाओ।
  • सूची से सभी समाप्ति / त्रुटि-फेंकने वाले कार्यक्रमों को हटा दें
  • स्वच्छ रूप से रुके * कार्यक्रम का उत्पादन करें
  • सूची में कुछ और कार्यक्रम जोड़ें
  • प्रत्येक कार्यक्रम को बदले में, पुराने कार्यक्रमों के निष्पादन को उठाते हुए छोड़ दें जहां यह छूट गया है
  • सूची से सभी समाप्ति / त्रुटि-फेंकने वाले कार्यक्रमों को हटा दें
  • स्वच्छ रूप से रुके * कार्यक्रम का उत्पादन करें
  • दोहराना

* आपको केवल उन कार्यक्रमों को आउटपुट करना चाहिए जो सफाई से रोकते हैं। इसका मतलब है कि निष्पादन के दौरान कोई वाक्यविन्यास त्रुटियां या अनकही अपवाद नहीं थे। प्रोग्राम जो इनपुट मांगते हैं, उन्हें भी आउटपुट किए बिना समाप्त किया जाना चाहिए। यदि कोई प्रोग्राम आउटपुट का उत्पादन करता है, तो आपको इसे समाप्त नहीं करना चाहिए, बस आउटपुट को फेंक देना चाहिए।

अधिक नियम

  • आपको परीक्षण किए गए कार्यक्रमों को शामिल करने के लिए नए थ्रेड्स नहीं करना चाहिए, क्योंकि यह होस्ट ओएस / अन्य सॉफ़्टवेयर पर समानांतरकरण का काम बंद करता है।
  • संपादित करें: संभावित भविष्य की खामियों को बंद करने के लिए, आपको परीक्षण किए गए प्रोग्राम के कोड का evalएक हिस्सा (या किसी भी संबंधित फ़ंक्शन) की अनुमति नहीं है । आप दुभाषिया के कोड से एक कोडब्लॉक कर सकते हैं । (इन नियमों के तहत बीएफ-इन-पायथन जवाब अभी भी मान्य है।) eval
  • यह
  • जिस भाषा में आप अपना सबमिशन लिखते हैं, वह वैसी नहीं होनी चाहिए, जिस भाषा का आप परीक्षण / आउटपुट कर रहे हैं।
  • आपको यह मान लेना चाहिए कि आपकी उपलब्ध मेमोरी अनबाउंड है।
  • ट्यूरिंग-पूर्णता साबित करते समय, आप यह मान सकते हैं कि इनपुट प्रोग्राम में हार्डकोड किया गया है, और आउटपुट को प्रोग्राम की आंतरिक स्थिति से पढ़ा जा सकता है।
  • यदि आपका प्रोग्राम खुद को आउटपुट करता है, तो यह संभवतः गलत है या एक पॉलीग्लॉट है।

7
मुझे यह महसूस करने में बहुत लंबा समय लगा कि क्यों"If your program outputs itself, it is probably wrong or a polyglot."
ट्राइकोप्लाक्स

1
क्या हम मान सकते हैं कि उपलब्ध स्मृति
अबाधित है

1
@ शक हां, और यह निश्चित रूप से अन्यथा संभव नहीं है।
PhiNotPi 16

1
अनुवर्ती चुनौती ( बहुत कठिन): हर गैर-रोक कार्यक्रम को आउटपुट करें।
मिलो ब्रान्ड

1
क्या एक ही प्रोग्राम को एक से अधिक बार आउटपुट करना स्वीकार्य है?

जवाबों:


9

पाइथन में subleq OISC, 317 269 ​​बाइट्स

import collections
g=0
P={}
while 1:
    P[g]=[[0],collections.defaultdict(int,enumerate(list(int(x)for x in reversed(str(g)))))]
    g+=1
    for o,[a,p]in P.items():
        i=a[0]
        p[i+p[i+1]]-=p[i+p[i]]
        if p[i+p[i+1]]<=0:a[0]+=p[i+2]
        else:a[0]+=3
        if a[0]<0:print o;del P[o]

https://esolangs.org/wiki/Subleq

एक subleq प्रोग्राम पूर्णांक (p) और एक निर्देश सूचक (i) की एक एक्स्टेंसिबल सूची है। यह सुबल वेरिएंट रिश्तेदार संबोधन का उपयोग करता है, जो विकी टॉक पेज से पता चलता है कि बंधे हुए मूल्यों के साथ पूर्णता के लिए आवश्यक है। प्रत्येक टिक, ऑपरेशन p[i+p[i+1]]-=p[i+p[i]]किया जाता है, और फिर i+=p[i+2]यदि ऑपरेशन का परिणाम <= 0 था, अन्यथा i+=3। अगर मैं कभी नकारात्मक होता हूं, तो कार्यक्रम रुक जाता है।

यह कार्यान्वयन हर कार्यक्रम का परीक्षण करता है, जिसकी प्रारंभिक स्थिति 0 के प्रारंभिक अनुदेश सूचक के साथ एक-अंकीय गैर-नकारात्मक पूर्णांक (0-9) से युक्त होती है।

Output:
21 (which represents the program [1 2 0 0 0 0 0...]
121
161
221
271
351
352
461
462
571
572
681
682
791
792

उत्पादन उलट है, गोल्फ कारणों से। ऊपर की कल्पना को उल्टा रखा जा सकता है, लेकिन फिर कार्यान्वयन में उपयोग किए गए कोड से मेल नहीं खाएगा, इसलिए मैंने इसे इस तरह से वर्णित नहीं किया है।

संपादित करें: पहला प्रोग्राम जो सरल निर्बाध विकास को प्रदर्शित करता है, वह 14283 है, जो मेमोरी लोकेशन 6 पर मूल्य को घटाता है और अगले नकारात्मक सेल में प्रत्येक 3 टिक्स पर एक स्पष्ट 0 (हर सेल में निहित 0 के विपरीत) लिखता है।


9

बिटज साइक्लिक टैग सीजेएम में, 98 87 84 77 बाइट्स

L{Z):Z2b1>_,,1>\f{/([\:~]a2*}+{)~[\({1+(:X+\_0=Xa*+}{0+\1>}?_{]a+}{];p}?}%1}g

चूंकि यह एक अनन्त लूप है, आप सीधे ऑनलाइन दुभाषिया में इसका परीक्षण नहीं कर सकते। हालांकि, यहां एक वैकल्पिक संस्करण है जो आपके साथ खेलने के लिए STDIN से पुनरावृत्तियों की संख्या को पढ़ता है। पूर्ण कार्यक्रम का परीक्षण करने के लिए, आपको जावा दुभाषिया की आवश्यकता होगी ।

बीसीटी चक्रीय टैग सिस्टम का एक न्यूनतम संस्करण है । एक प्रोग्राम को दो बाइनरी स्ट्रिंग्स द्वारा परिभाषित किया गया है: निर्देशों का एक (चक्रीय) सूची और एक प्रारंभिक अवस्था। कार्यक्रमों को प्रिंट करते समय मेरे जीवन को आसान बनाने के लिए, मैंने अपनी स्वयं की धारणा को परिभाषित किया है: प्रत्येक तार को पूर्णांक की सीजेएम-शैली की सरणी के रूप में दिया गया है, और पूरे कार्यक्रम को चारों ओर से घेर लिया गया है [[...]], जैसे।

[[[0 0 1 1] [0 1 1 1 0]]]

मैं खाली प्रारंभिक राज्यों या खाली अनुदेश सूचियों को भी अस्वीकार कर रहा हूं।

बीसीटी में दिए गए निर्देशों की व्याख्या इस प्रकार है:

  • यदि निर्देश है 0, तो वर्तमान स्थिति से अग्रणी बिट को हटा दें।
  • यदि निर्देश है 1, तो निर्देश सूची से एक और बिट पढ़ें, कॉल करें X। यदि वर्तमान स्थिति से अग्रणी बिट है, तो वर्तमान स्थिति में 1जोड़ें X, अन्यथा कुछ भी न करें।

यदि वर्तमान स्थिति कभी खाली हो जाती है, तो कार्यक्रम रुक जाता है।

पहले कुछ पड़ाव कार्यक्रम हैं

[[[0] [0]]]
[[[0] [1]]]
[[[0 0] [0]]]
[[[0] [0 0]]]
[[[0 0] [1]]]
[[[0] [0 1]]]
[[[0 1] [0]]]
[[[0] [1 0]]]
[[[0 1] [1]]]
[[[0] [1 1]]]

यदि आप अधिक देखना चाहते हैं, तो ऊपर दिए गए ऑनलाइन दुभाषिया में संस्करण की जाँच करें।

व्याख्या

यहाँ कोड कैसे काम करता है। डाइविंग का ट्रैक रखने के लिए हम हमेशा स्टैक पर एक सरणी रखेंगे जिसमें सभी प्रोग्राम शामिल हैं। प्रत्येक कार्यक्रम कार्यक्रम कोड (जैसे [[0 1 0] [1 0]]) के आंतरिक प्रतिनिधित्व और साथ ही कार्यक्रम की वर्तमान स्थिति की जोड़ी है । हम केवल गणना करने के लिए उत्तरार्द्ध का उपयोग करेंगे, लेकिन एक बार इसे रोकने के बाद हमें कार्यक्रम को प्रिंट करने के लिए पूर्व को याद रखना होगा। कार्यक्रमों की यह सूची केवल एक खाली सरणी के साथ आरंभिक है L

कोड के बाकी एक अनंत लूप है {...1}gजो पहले इस सूची में एक या एक से अधिक प्रोग्राम जोड़ता है और प्रत्येक प्रोग्राम पर एक चरण की गणना करता है। जिन कार्यक्रमों को रोक दिया जाता है उन्हें सूची से मुद्रित और हटा दिया जाता है।

मैं बाइनरी नंबर की गिनती करके कार्यक्रमों की गणना कर रहा हूं। अग्रणी अंक यह सुनिश्चित करने के लिए छीन लिया जाता है कि हम सभी कार्यक्रमों को अग्रणी 0s के साथ भी प्राप्त कर सकते हैं। प्रत्येक ऐसे छंटनी वाले द्विआधारी प्रतिनिधित्व के लिए, मैं निर्देशों और प्रारंभिक स्थिति के बीच प्रत्येक संभावित विभाजन के लिए एक कार्यक्रम को धक्का देता हूं। उदाहरण के लिए यदि काउंटर वर्तमान में है 42, तो इसका बाइनरी प्रतिनिधित्व है 101010। हम 1सभी गैर-खाली स्प्लिटिंग को आगे बढ़ाते हैं:

[[[0] [1 0 1 0]]]
[[[0 1] [0 1 0]]]
[[[0 1 0] [1 0]]]
[[[0 1 0 1] [0]]]

चूंकि हम खाली निर्देश या राज्य नहीं चाहते हैं, इसलिए हम 4 पर काउंटर शुरू करते हैं, जो देता है [[[0] [0]]]। यह गणना निम्नलिखित कोड द्वारा की जाती है:

Z):Z    e# Push Z (initially 3), increment, and store in Z.
2b1>    e# Convert to base 2, remove initial digit.
_,      e# Duplicate and get the number of bits N.
,1>     e# Turn into a range [1 .. N-1].
\       e# Swap the range and the bit list.
f{      e# Map this block onto the range, copying in the bit list on each iteration.
  /     e#   Split the bit list by the current value of the range.
  (     e#   Slice off the first segment from the split.
  [     
    \:~ e#   Swap with the other segments and flatten those.
  ]     e#   Collect both parts in an array.
  a2*   e#   Make an array that contains the program twice, as the initial state is the
        e#   same as the program itself.
}
+       e# Add all of these new programs to our list on the stack.

बाकी कोड कार्यक्रमों की सूची पर एक ब्लॉक को मैप करता है, जो इन जोड़ियों के दूसरे छमाही पर बीसीटी गणना का एक चरण करता है और अगर यह रुकता है तो प्रोग्राम को हटा देता है:

)~     e# Remove the second half of the pair and unwrap it.
[      e# We need this to wrap the instructions and current state back in an array
       e# again later.
\(     e# Bring the instruction list to the top and remove the leading bit.
{      e# If it's a 1...
  1+   e#   Append a 1 again (the instructions are cyclic).
  (:X+ e#   Remove the next bit, store it in X and also append it again.
  \_0= e#   Bring the current state to the top, get its first bit.
  Xa*+ e#   Append X if that bit was 1 or nothing otherwise.
}{     e# Else (if it's a 0...)
  0+   e#   Append a 0 again (the instructions are cyclic).
  \1>  e#   Discard the leading bit from the current state.
}?
_      e# Duplicate the current state.
{      e# If it's non-empty...
  ]a+  e#   Wrap instructions and state in an array and add them to the program
       e#   pair again.
}{     e# Else (if it's empty)...
  ];p  e# Discard the instructions and the current state and print the program.
}?

अच्छा (+1)। कुछ बाइट्स को इस तथ्य का उपयोग करके बचाया जा सकता है कि BCT पूरा ट्यूरिंग है भले ही प्रारंभिक डेटास्ट्रिंग (आपके "राज्य") के रूप में केवल 1 का उपयोग करने के लिए प्रतिबंधित हो। उदाहरण के लिए, बाइनरी में प्रत्येक क्रमिक धनात्मक पूर्णांक की व्याख्या 1P के रूप में करें, फिर P को 1 पर निष्पादित करें और आउटपुट P iff का निष्कासन समाप्त हो जाता है (फिर से दोहराता है)। (बेशक, कोई भी P जो 0 से शुरू होता है, तब वह सूची में होगा, क्योंकि वह तुरंत प्रारंभिक डेटास्ट्रिंग को हटा देगा।)
res

8

पायथन में ब्रेनफक, 567 बाइट्स

एक अपेक्षाकृत सरल समाधान, ब्रेनफैक के लिए दुभाषिया लिखने के लिए शायद ही सबसे कठिन भाषा है।

ब्रेनफक के इस कार्यान्वयन में 0 से शुरू होने वाला डेटा पॉइंटर है, केवल एक सकारात्मक मान लेने की अनुमति है (यदि इसे 0 के बाईं ओर जाने की कोशिश करता है तो एक त्रुटि माना जाता है)। डेटा कोशिकाएं 0 से 255 तक मान ले सकती हैं और लपेट सकती हैं। 5 मान्य निर्देश हैं ><+[]( -रैपिंग के कारण अनावश्यक है)।

मुझे लगता है कि आउटपुट अब ठीक है, हालांकि यह सुनिश्चित करना मुश्किल है कि यह हर संभव समाधान को प्रिंट कर रहा है इसलिए मुझे कुछ याद आ रहा है।

o="><+]["
A="[]if b%s1<0else[(p,a+1,b%s1,t+[0],h)]"
C="[(p,h[a]+1,b,t,h)if t[b]%s0else(p,a+1,b,t,h)]"
I=lambda s,i:i*">"if""==s else o[o.find(s[0])+i-5]+I(s[1:],i*o.find(s[0])>3)
s="";l=[]
while 1:
 s=I(s,1)
 r=[];h={}
 for i in range(len(s)):
    if s[i]=="[":r+=[i]
    if s[i]=="]":
     if r==[]:break
     h[r[-1]]=i;h[i]=r[-1];r=r[:-1]
 else:
    if r==[]:
     l+=[(s,0,0,[0],h)];i=0
     while i<len(l):
        p,a,b,t,h=l[i]
        if a>=len(p):print p;l[i:i+1]=[]
        else:l[i:i+1]=eval([A%("+","+"),A%("-","-"),"[(p,a+1,b,t[:b]+[(t[b]+1)%256]+t[b+1:],h)]",C%">",C%"=="][o.find(p[a])]);i+=1

पहले कुछ ouputs:

>
+
>>
+>
><
>+
++
[]
>>>
+>>

और पहले 2000 की सूची: http://pastebin.com/KQG8PVJn

और अंत []में उनके साथ पहले 2000 आउटपुट की एक सूची : http://pastebin.com/iHWwJprs
(बाकी सभी तुच्छ हैं जब तक वे वैध हैं)

ध्यान दें कि आउटपुट एक क्रमबद्ध क्रम में नहीं है, हालांकि यह उनमें से कई के लिए इस तरह प्रकट हो सकता है, क्योंकि जो कार्यक्रम लंबे समय तक लगते हैं, उन्हें बाद में मुद्रित किया जाएगा।


1
दोनों नंगे [-]और [+]निश्चित रूप से दिखाई देने चाहिए, क्योंकि लूप की सामग्री को केवल ऊपर छोड़ दिया जाता है (कोई लपेटन शामिल नहीं)।
PhiNotPi

@ Sp3000 [-]और [+]एक बग था जिसे अब तय किया जाना चाहिए और मैंने सेटिंग्स के साथ अपडेट किया है
KSab

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

@ मार्टिनबटनर मुझे लगता है कि इस प्रश्न को गलत समझा गया है; मैंने 'ट्यूरिंग पूरा सब्मिट' भाग नहीं पढ़ा। हालाँकि यह चुनौती लगभग (अधिकांश) भाषाओं के बराबर नहीं है? बस आप ब्रेनफक (या शायद कुछ भी सरल) के साथ 1 से 1 प्रतिस्थापन कर सकते हैं, उदाहरण के लिए सी कोड यहां: en.wikipedia.org/wiki/Brainfuck#Commands
केसाब

2
पर एक नजर डालें stackoverflow.com/questions/1053931/... विशेष रूप से OISC प्रविष्टि। इसके अलावा, सीए नियम 110 और चक्रीय टैग सिस्टम देखें। इस चुनौती में रचनात्मक रूप से ट्यूरिंग पूर्ण "भाषा" चुनने के लिए बहुत जगह है।
21

5

पायथन में स्लैश, 640 498 बाइट्स

g=2
P={}
while 1:
    b=bin(g)[3:]
    P[b]=[[0],['',''],[b]]
    g+=1
    for d,[a,b,c]in P.items():
        s=c[0]
        if a[0]:
            if s.count(b[0]):s=s.replace(b[0],b[1],1)
            else:a[0]=0
        else:
            if s[0]=='0':
                if len(s)==1:del P[d];continue
                s=s[2:]
            else:
                b[0]=b[1]=''
                a[0]=1
                t=p=0
                while t<2:
                    p+=1
                    if p>=len(s):break
                    if s[p]=='0':
                        if p+1>=len(s):break
                        b[t]+=s[p+1]
                        p+=1
                    else:t+=1
                if t<2:del P[d];continue
        c[0]=s
        if len(s)==0:print d;del P[d]

https://esolangs.org/wiki////

एक स्लैश प्रोग्राम एक स्ट्रिंग है, इस दुभाषिया में पात्रों '/' और '\' तक सीमित है। इस कार्यान्वयन में, अजगर के बिन (x) के उपयोग के साथ कुछ गोल्फ के लिए अनुमति देने के लिए '1' और \ '0' है। जब दुभाषिया a \ _ का सामना करता है, तो अगला वर्ण आउटपुट होता है और दोनों वर्ण हटा दिए जाते हैं। जब इसका a / से सामना होता है, तो यह खोज को खोजता है और प्रतिमानों के रूप में / खोज / प्रतिस्थापित / सहित / बच गए वर्णों को पैटर्न के भीतर (\\ प्रतिनिधित्व करता है \ _ और / / का प्रतिनिधित्व करता है)। इसके बाद ऑपरेशन को फिर से स्ट्रिंग पर बार-बार तब तक किया जाता है जब तक कि सर्च स्ट्रिंग मौजूद नहीं होता है, फिर से व्याख्या फिर से शुरू होती है। कार्यक्रम खाली होने पर रुकता है। यदि कोई अनुपस्थित सेट / पैटर्न या a है, तो इसके बाद कोई वर्ण नहीं होने पर एक कार्यक्रम को मार दिया जाएगा।

Example output and explanations:
01 outputs '1' and halts
00 outputs '0' and halts
0101 outputs '11' and halts
0100 ...
0001
0000
010101
010100
010001
010000 ...
101110 replaces '1' with '', leaving '00', which outputs '0' and halts

4

जावा में ट्रीगर , 1,299 1,257 1,251 1,207 1,203 1,201 1,193 1,189 बाइट्स

import java.util.*;class I{static class N{N l,r;byte v;}static class T extends Stack<N>{{push(new N());}void p(){pop();if(size()==0)p();}int i,h;char[]s;}static void s(T t){if(t.i>=t.s.length){t.h=1;return ;}char c=t.s[t.i];if(c=='<'){if(t.peek().l==null)t.peek().l=new N();t.push(t.peek().l);}if(c=='>'){if(t.peek().r==null)t.peek().r=new N();t.push(t.peek().r);}if(c=='^')t.p();if(c=='+')t.peek().v++;if(c=='-')t.peek().v--;if(c=='['&&t.peek().v==0){int i=1;while(i>0){t.i++;if(t.s[t.i]==']')i--;if(t.s[t.i]=='[')i++;}return;}if(c==']'&&t.peek().v!=0){int i=1;while(i>0){t.i--;if(t.s[t.i]==']')i++;if(t.s[t.i]=='[')i--;}return;}t.i++;}static char[]n(char[]a){String b="<^>[+-]";int q=a.length;for(int i=q-1;i>=0;i--){int j=b.indexOf(a[i]);if(j<6){a[i]=b.charAt(j+1);return a;}a[i]='<';}a=Arrays.copyOf(a,q+1);a[q]='<';return a;}public static void main(String[]a){List<T>z=new ArrayList<T>();char[]c={};while(true){T t=new T();t.s=c;if(b(c))z.add(t);c=n(c.clone());for(T u:z)try{s(u);if(u.h>0){z.remove(u);System.out.println(u.s);break;}}catch(Exception e){z.remove(u);break ;}}}static boolean b(char[]c){int i=0;for(char d:c){if(d=='[')i++;if(d==']')i--;if(i<0)return 0>0;}return i==0;}}

4

ब्रेकीलॉगपोस्ट पत्राचार समस्या , 10 बाइट्स

≜;?{~c}ᵐ\d

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

फ़ंक्शन जो एक जनरेटर है जो सभी संभावित पोस्ट पत्राचार समस्याओं को उत्पन्न करता है जिसके लिए अंत में हल करने के लिए जानवर-मजबूर समाधान। (पोस्ट पत्राचार की समस्या के लिए ब्रूट-फोर्सिंग सॉल्यूशंस को ट्यूरिंग-पूर्ण ऑपरेशन के रूप में जाना जाता है।) TIO लिंक में एक हेडर होता है जो एक जनरेटर को एक पूर्ण प्रोग्राम में परिवर्तित करता है, और प्रत्येक आउटपुट को तुरंत उत्पन्न करता है (जैसे, जब वायो मारता है। निष्पादन समय के 60 सेकंड से अधिक खपत के कारण कार्यक्रम, अब तक उत्पादित आउटपुट दिखाई दे रहा है)।

यह उस समस्या के एक सूत्रीकरण का उपयोग करता है जिसमें तार को अंकों के तारों के रूप में दिया जाता है, अग्रणी शून्य को 0स्वयं को छोड़कर अनुमति नहीं दी जाती है, अग्रणी शून्य से जुड़ी समस्या के समाधान को स्वीकार नहीं किया जाता है, और अंकों की एक स्ट्रिंग का प्रतिनिधित्व किया जा सकता है या तो संख्या , या संख्या घटाकर। स्पष्ट रूप से, इसका किसी पर भी भाषा के ट्यूरिंग-पूर्णता पर कोई प्रभाव नहीं पड़ता है (क्योंकि अंक शून्य का उपयोग करने के लिए पोस्ट पत्राचार समस्या की कोई आवश्यकता नहीं है)।

यह कार्यक्रम समस्याओं के सभी संभावित समाधानों को उत्पन्न करने के माध्यम से काम करता है, फिर उनके द्वारा हल किए गए मूल कार्यक्रमों को खोजने के लिए पीछे की ओर काम करता है। जैसे, एक व्यक्तिगत कार्यक्रम कई बार आउटपुट हो सकता है। यह स्पष्ट नहीं है कि यह उत्तर को अमान्य करता है या नहीं; ध्यान दें कि सभी हॉल्टिंग कार्यक्रम अंततः कम से कम एक बार (वास्तव में, अनंत बार कई बार आउटपुट होंगे, क्योंकि किसी भी प्रोग्राम में जिसके समाधान अनंत रूप से कई समाधान हैं), और गैर-हॉल्टिंग प्रोग्राम कभी भी आउटपुट नहीं होंगे।

व्याख्या

≜;?{~c}ᵐ\d
≜           Brute-force all numbers:
 ;?           Pair {the number} with {itself}
   {  }ᵐ      For each pair element:
    ~c          Brute-force a partition of that element into substrings
        \     such that the two elements each have the same number of substrings
        \     and group together corresponding substrings
         d    and remove duplicated pairs {to produce a possible output}

2

सीलोन में "बैंगनी बिना I / O", 662

import ceylon.language{l=variable,I=Integer,m=map,S=String}class M(S d){l value t=m{*d*.hash.indexed};l I a=0;l I b=0;l I i=0;I g(I j)=>t[j]else 0;value f=m{97->{a},98->{b},65->{g(a)},66->{g(b)},105->{i},49->{1}};value s=m{97->((I v)=>a=v),98->((I v)=>b=v),65->((I v)=>t=m{a->v,*t}),66->((I v)=>t=m{b->v,*t}),105->((I v)=>i=v)};I&I(I)x{throw Exception(d);}I h(I v)=>f[v]?.first else x;shared void p(){(s[g(i)]else x)(h(g(i+1))-h(g(i+2)));i+=3;}}shared void run(){value a='!'..'~';{S*}s=expand(loop<{S*}>{""}((g)=>{for(c in a)for(p in g)p+"``c``"}));l{M*}r={};for(p in s){r=[M(p),*r];for(e in r){try{e.p();}catch(x){print(x.message);r=r.filter(not(e.equals));}}}}

बैंगनी एक स्व-संशोधित एक-निर्देश भाषा है जिसे यहां व्याख्या करने के लिए कहा गया था । इनपुट और आउटपुट इस कार्य के लिए प्रासंगिक नहीं हैं के रूप में, मैं हटा दिया oदुभाषिया से प्रतीक का अर्थ है, ऐसा है कि (संभावित) वैध प्रतीकों बस कर रहे हैं a, b, A, B, iऔर 1(पिछले सिर्फ पढ़ने के लिए एक, लिखने के लिए नहीं)।

लेकिन जैसा कि पर्पल स्व-संशोधित है (और डेटा के रूप में अपने स्रोत कोड का उपयोग कर रहा है), संभावित रूप से उन पात्रों के अलावा अन्य प्रोग्राम भी उपयोगी हैं, इसलिए मैंने कोड में सभी प्रिंट करने योग्य (गैर-व्हाट्सएप) एएससीआईआई पात्रों की अनुमति देने का विकल्प चुना (अन्य) के रूप में अच्छी तरह से उपयोगी है, लेकिन आसानी से मुद्रित नहीं हैं)।

(आप कमांड लाइन तर्क के रूप में अनुमत पात्रों के स्ट्रिंग के रूप में व्याख्या करने के लिए दुभाषिया को संशोधित कर सकते हैं - aनीचे परिभाषित लाइन पर टिप्पणी करें। फिर लंबाई 686 बाइट्स हो जाती है।)

मेरा "समानांतर" दुभाषिया इस प्रकार उन पात्रों से सभी परिमित तार बनाता है (लंबाई और बढ़ती क्रम में) और उनमें से प्रत्येक की कोशिश करता है।

जब भी निष्पादन के लिए टेप से पढ़ी जाने वाली कमांड मान्य नहीं होती है, तो पर्पल बिना त्रुटि के रुकेगा - इस प्रकार अमान्य कार्यक्रम और कई, कई रुकने वाले नहीं हैं। (अधिकांश स्टेप पहले स्टेप पर भी, केवल 3 लंबाई वाले कुछ प्रोग्राम दूसरे स्टेप पर आते हैं (और तब रुक जाएंगे), पहले नॉन-हॉल्टिंग की लंबाई 6 होती है।

मुझे लगता है कि मेरे दुभाषिया द्वारा आजमाए गए क्रम में पहला पहला नॉन-हॉल्टिंग प्रोग्राम है aaaiaa, जो पहले चरण में aरजिस्टर को 0 पर सेट करता है (जो कि यह पहले से ही था), और दूसरा और प्रत्येक निम्न चरण निर्देश सूचक को 0 पर सेट करता है, इसे iaaफिर से निष्पादित करने के लिए ।

मैंने "मानक" पर्पल के मेरे दुभाषिया के लिए लिखे गए कोड का कुछ हिस्सा पुन: उपयोग किया , लेकिन इनपुट और आउटपुट को हटाने के कारण, मेरे समानांतर दुभाषिया उससे भी थोड़ा छोटा हो जाता है, जबकि एक साथ कई कार्यक्रमों को निष्पादित करने के लिए अतिरिक्त तर्क भी शामिल है।

यहाँ एक टिप्पणी और स्वरूपित संस्करण है:

// Find (enumerate) all halting programs in (a non-I/O subset of) Purple.
//
// Question:  /codegolf//q/51273/2338
// My answer: /codegolf//a/65820/2338

// We use a turing-complete subset of the Purple language,
// with input and output (i.e. the `o` command) removed.

import ceylon.language {
    l=variable,
    I=Integer,
    m=map,
    S=String
}

// an interpreting machine.
class M(S d) {
    // The memory tape, as a Map<Integer, Integer>.
    // We can't modify the map itself, but we
    // can replace it by a new map when update is needed.
    l value t = m {
        // It is initialized with the code converted to Integers.
        // We use `.hash` instead of `.integer` because it is shorter.
        *d*.hash.indexed
    };

    // three registers
    l I a = 0;
    l I b = 0;
    l I i = 0;

    // get value from memory
    I g(I j) =>
            t[j] else 0;

    // Map of "functions" for fetching values.
    // We wrap the values in iterable constructors for lazy evaluation
    //  – this is shorter than using (() => ...).
    // The keys are the (Unicode/ASCII) code points of the mapped
    // source code characters.
    value f = m {
        // a
        97 -> { a },
        // b
        98 -> { b },
        // A
        65 -> { g(a) },
        // B
        66 -> { g(b) },
        // i
        105 -> { i },
        // 1
        49 -> { 1 }
    };

    // Map of functions for "storing" results.
    // The values are void functions taking an Integer,
    // the keys are the ASCII/Unicode code points of the corresponding
    // source code characters.
    value s = m {
        // a
        97 -> ((I v) => a = v),
        // b
        98 -> ((I v) => b = v),
        // Modification of the memory works by replacing the map with
        // a new one.
        // This is certainly not runtime-efficient, but shorter than
        // importing ceylon.collections.HashMap.
        // A
        65 -> ((I v) => t = m { a->v, *t }),
        // B
        66 -> ((I v) => t = m { b->v, *t }),
        // i
        105 -> ((I v) => i = v)
    };


    // Exit the interpretation, throwing an exception with the machine's
    // source code as the message.  The return type is effectively `Nothing`,
    // but shorter (and fits the usages).
    I&I(I) x {
        throw Exception(d);
    }

    // accessor function for the f map
    I h(I v) =>
            f[v]?.first else x;

    // a single step
    shared void p() {
        (s[g(i)] else x)(h(g(i + 1)) - h(g(i + 2)));
        i += 3;
    }
}

// the main entry point
shared void run() {
    // the alphabet of "Purple without I/O".
    value a = '!'..'~';
    //// possible alternative to use a command line argument:
    // value a = process.arguments[0] else '!'..'~';

    // an iterable consisting of all programs in length + lexicographic order
    {S*} s =
            // `expand` creates a single iterable (of strings, in this case)
            // from an iterable of iterables (of strings).
             expand(
        // `loop` creates an iterable by applying the given function
        // on the previous item, repeatedly.
        // So here we start with the iterable of length-zero strings,
        // and in each iteration create an iterable of length `n+1` strings
        // by concatenating the length `n` strings with the alphabet members.
        loop<{S*}>{ "" }((g) =>
                {
                    for (c in a)
                        for (p in g)
                            p + "``c``"
                }));

    // This is a (variable) iterable of currently running machines.
    // Initially empty.
    l {M*} r = {};

    // iterate over all programs ...
    for(p in s) {
        // Create a machine with program `p`, include it
        //  in the list of running machines.
        //
        // We use a sequence constructor here instead of
        //  an iterable one (i.e. `r = {M(p, *r)}` to prevent
        // a stack overflow when accessing the deeply nested
        // lazy iterable.
        r = [M(p), *r];
        // iterate over all running machines ...
        for(e in r) {
            try {
                // run a step in machine e.
                e.p();
            } catch(x) {
                // exception means the machine halted.
                // print the program
                print(x.message);
                // remove the machine from the list for further execution
                r = r.filter(not(e.equals));
            }
        }
        // print(r.last);
    }
}

2

हास्केल में एसके कॉम्बिनेटर कैलकुलस , 249 बाइट्स

data C=H|S|K|C:$C deriving(Eq,Show)
n(a:$b)=m a*n b
n a=m a
m S=1
m K=1
m(S:$a)=n a
m _=0
f H=[S,K,S:$H,K:$H,S:$H:$H]
f a=[S:$b:$c:$d|b:$d:$(c:$e)<-[a],d==e,n b*n c*n d>0]++[K:$a:$H|n a>0]++do b:$c<-[a];[d:$c|d<-f b]++[b:$d|n b>0,d<-f c]
l=H:(f=<<l)

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

यह काम किस प्रकार करता है

एसके कॉम्बिनेटर कलन के लिए कॉल-बाय-वैल्यू मूल्यांकन नियम इस प्रकार हैं:

(ए) एस xyz z xz ( yz ), सामान्य रूप में x , y , z के लिए ;
(ख) कश्मीर xyएक्स , के लिए एक्स , वाई सामान्य रूप में;
(ग) xyएक्स ' y , अगर एक्सएक्स ';
(घ) xyxy ', के लिए एक्स सामान्य रूप, अगर में वाईवाई'

चूँकि हम केवल व्यवहार को रोकने में रुचि रखते हैं, हम सामान्य रूप में नहीं है, लेकिन एक प्रतीक एच शुरू करके भाषा का थोड़ा विस्तार करते हैं, लेकिन सभी सामान्य रूपों "मूल्यांकन":

(ए) एस xyz z xz ( yz ), सामान्य रूप में x , y , z के लिए ;
(b K) K x H ′ x , सामान्य रूप में x के लिए ;
(ग) xyएक्स ' y , अगर एक्सएक्स ';
(घ) xyxy ', के लिए एक्स सामान्य रूप में, अगर yवाई' ;
(ई) एस S एच;
(च) के f एच;
(छ) एसएच; एच;
(एच) केएच; एच;
(i) एसएचएच। एच।

हम किसी भी आवेदन H x को एक रन-टाइम त्रुटि मानते हैं जैसे कि यह एक अनंत लूप था, और हम मूल्यांकन का आदेश देते हैं कि कोई भी H (e) द्वारा निर्मित नहीं है - (i) एक संदर्भ में जहां यह होगा नजरअंदाज कर दिया (शीर्ष स्तर, किसी भी कश्मीर एक्स ☐, किसी भी नजरअंदाज कर दिया K☐, किसी भी नजरअंदाज कर दिया एस एक्स ☐ के लिए एक्स सामान्य रूप में, किसी भी नजरअंदाज कर दिया S☐H)। इस तरह हम H की कमी वाले सामान्य शब्दों के रूखे व्यवहार को प्रभावित नहीं करते हैं।

इन संशोधित नियमों का लाभ यह है कि हर सामान्य शब्द का एच के लिए एक अद्वितीय मूल्यांकन पथ है, और यह कि हर शब्द में ↦ के तहत संभावित पूर्वग्रहों की एक सीमित संख्या है। इसलिए डोवेटिंग दृष्टिकोण का उपयोग करने के बजाय, हम एच से सभी रिवर्स मूल्यांकन पथों की अधिक कुशल चौड़ाई-पहली खोज कर सकते हैं।

nयह जाँच करता है कि क्या कोई शब्द सामान्य रूप में है, fएक शब्द के सभी संभावित पूर्वावस्थाओं को ढूँढता है, और lएच से प्रथम-चौड़ाई खोज द्वारा निर्मित सामान्यीकरण की शर्तों की एक आलसी अनंत सूची है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.