ट्यूरिंग-पूर्ण भाषा दुभाषिया

Question

एक चुनौती जिसे मैंने सोचा था कि आपके चयन की ट्यूरिंग-पूर्ण भाषा के लिए एक दुभाषिया बनाना बहुत अच्छा होगा ।

नियम सरल हैं:

1. आप इस व्याख्याकार को बनाने के लिए किसी भी भाषा का उपयोग कर सकते हैं, भले ही वह इस चुनौती से नया हो।
2. आप किसी भी ट्यूरिंग-पूर्ण भाषा का उपयोग तब तक कर सकते हैं जब तक कि वह वही न हो जो आप इसे लिख रहे हैं।
3. आप उदाहरण के लिए eval फ़ंक्शन का उपयोग करके कोड का मूल्यांकन नहीं कर सकते।
4. इस बात का स्पष्टीकरण कि आपने कैसे संपर्क किया, यह अच्छा होगा लेकिन इसकी आवश्यकता नहीं है।
5. यह बाइट में स्कोर किया जाएगा।
6. प्रत्येक सबमिशन पूरी तरह से काम करना चाहिए, जिसका अर्थ है कि आपकी चुनी हुई भाषा में मौजूद हर सुविधा मौजूद होनी चाहिए।

सीधे शब्दों में कहें:

आपका कार्य किसी भी ट्यूरिंग-पूर्ण भाषा के लिए अपने चयन की किसी भी भाषा के साथ एक कार्यशील दुभाषिया बनाना है।

सौभाग्य!

Comments

मैं एक नियम की भी सिफारिश करूंगा कि कार्यान्वित भाषा उस भाषा से भिन्न होनी चाहिए जिसे आप इसे लागू करने के लिए उपयोग करते हैं, तुच्छ eval-समान समाधानों को रोकने के लिए ।

— ETHproductions

वास्तव में, आप केवल evalकमांड / फ़ंक्शंस पर प्रतिबंध लगाना चाह सकते हैं , क्योंकि कुछ भाषाओं ने कोड का मूल्यांकन दूसरी भाषा में किया है।

— ETHproductions

@arodebaugh भविष्य की चुनौतियों के लिए, आप अपने विचार को सैंडबॉक्स में पोस्ट कर सकते हैं, जहां आप फीडबैक प्राप्त कर सकते हैं और इस तरह से विवरण प्राप्त कर सकते हैं कि चुनौतियां लाइव हो जाती हैं और उत्तर दिया जाता है।

— मार्टिन एंडर

ठीक है, आपको शायद थोड़ा और विशिष्ट होना चाहिए और बैश + पर्ल जैसे अन्य तुच्छ उत्तर से बचने के लिए "आप किसी भी विधि के माध्यम से कोड को निष्पादित नहीं कर सकते हैं"।

— 23

प्रासंगिक वीडियो: PowerPoint की ट्यूरिंग संपूर्णता (SIGBOVIK) पर

— sergiol

Answer 1

Brachylog (2) → पोस्ट पत्राचार समस्या , 9 बाइट्स

~h=∋ᵐ\cᵐ=

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

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

ऊपर TIO लिंक में कार्यक्रम है [["a","baa"],["ab","aa"],["bba","bb"]], जिसे मैंने विकिपीडिया से कॉपी किया है। समाधान (जो प्रोग्राम काफी जल्दी पाता है) ["bbaabbbaa","bbaabbbaa"]।

व्याख्या

यह बहुत अधिक है बस पोस्ट पत्राचार समस्या का सीधा अनुवाद Brachylog में।

~h=∋ᵐ\cᵐ=
~h         Find {the shortest possible} list which starts with {the input}
  =        and for which all elements are equal
   ∋ᵐ      such that taking an element of each element,
     \cᵐ   and concatenating elements in corresponding positions,
        =  produces a list all of whose elements are equal.

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

Comments

और सामान्य रूप से "उन चीजों का कुंड जो अर्थपूर्ण हैं और बाइट्स को बचाएंगे, लेकिन ब्रेकीलॉग दुभाषिया इसे संभाल नहीं सकते हैं": पहले पांच बाइट्स को व्यक्त किया जा सकता है ~dp(जिसका मतलब काफी समान नहीं है, लेकिन अभी भी काफी करीब है ट्यूरिंग-पूर्ण), सिवाय इसके कि ब्रेकीलॉग दुभाषिया को पता नहीं है कि dअभी तक कैसे रिवर्स किया जाए।

Answer 2

जेली → "संक्रमण के लिए न्यूनतम जोड़ें", 5 4 बाइट्स

+"Ṃẞ

इसे ऑनलाइन आज़माएं! (टाइमआउट से बचने के लिए केवल एक पुनरावृत्ति चलाता है)

एक बहुत ही सरल ट्यूरिंग-पूर्ण निर्माण: हम एक वर्ग मैट्रिक्स को एक प्रोग्राम के रूप में लेते हैं, और हमेशा के लिए लूप लेते हैं, लेक्सिकोग्राफ़िक रूप से सबसे छोटी पंक्ति की पहचान करते हैं, फिर लेक्सिकोग्राफ़िक रूप से सबसे छोटे से पहली पंक्ति के प्रत्येक तत्व को बढ़ाते हैं, दूसरी पंक्ति के प्रत्येक तत्व को। लेक्सिकोग्राफिक रूप से सबसे छोटे तत्व के दूसरे तत्व द्वारा, और इसी तरह। (जेली कार्यक्रम " +"इनपुट के संबंधित तत्व {और Ṃमूल के न्यूनतम {मूल}, ẞलूप जोड़ें" है; यह मेरे पिछले कार्यक्रम की तुलना में एक बाइट है Z+ṂZß, जो बिल्कुल वैसा ही किया था। स्पष्ट रूप से मुझे गोल्फिंग पर ध्यान केंद्रित करना चाहिए था। जेली, लागू की गई भाषा को केवल गोल्फ नहीं बना रही है।)

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

Answer 3

कोनवे गेम ऑफ लाइफ की व्याख्या करते हुए गणितज्ञ, 64 बाइट्स

CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&

कॉनवे के गेम ऑफ लाइफ को ट्यूरिंग पूरा होने के लिए जाना जाता है; और सेलुलर ऑटोमेटा स्टीफन वोल्फ्राम के सबसे बुरे जुनून हैं। CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}एक नियम है जो कॉनवे के गेम ऑफ लाइफ के एक चरण के अनुसार 0s और 1s के दो आयामी सरणी को बदल देता है। (मुझे लगता है कि डिफ़ॉल्ट व्यवहार यह है कि यह सरणी इसके किनारों के चारों ओर घूमती है, इसलिए वास्तव में एक असतत टोरस है।) ~Nest~##&इस नियम को एक फ़ंक्शन में बदल देता है, जब एक प्रारंभिक बोर्ड राज्य (किसी आयाम का) और एक पूर्णांक nको तर्क के रूप में दिया जाता है, जो आउटपुट देता है। nजीवन के खेल के पुनरावृत्तियों का परिणाम ।

अपने स्वयं के आनंद के लिए, आप लिपटे संस्करण का उपयोग कर सकते हैं

b = RandomInteger[1,{50,50}];
Manipulate[ArrayPlot[
  CellularAutomaton@{224,{2,{t={2,2,2},{2,1,2},t}},{1,1}}~Nest~##&
    [b, n] ]
, {{n,0}, 0, 100, 1}]

और 50x50 बोर्ड पर 100 पीढ़ियों के माध्यम से अपना रास्ता स्क्रॉल करें।

Comments

अगर मैं सही ढंग से समझ रहा हूं, तो इसका एक निश्चित बोर्ड आकार है? उस स्थिति में, मुझे लगता है कि यह ट्यूरिंग-पूर्ण नहीं हो सकता है, क्या यह हो सकता है?

— DLosc

फ़ंक्शन के किसी भी विशेष कॉल में एक निश्चित बोर्ड आकार होता है, लेकिन उस बोर्ड का आकार मनमाने ढंग से बड़ा हो सकता है। (ध्यान दें कि पोस्ट की दूसरी छमाही में कोड का निरीक्षण करने का एक उदाहरण है, न कि वास्तविक कोड ही।)

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

मैं जो कह रहा हूं वह यह है कि GoL के लिए ट्यूरिंग-कम्प्लीट होना, यह एक ऐसे पैटर्न के लिए सक्षम होना है जो असीम रूप से बढ़ता है। (जैसे कि एक ग्लाइडर गन।) यदि यह कार्यान्वयन सरणी को एक चरण से दूसरे चरण तक नहीं बढ़ा सकता है, लेकिन इसे बजाय toroidally लपेटता है, तो यह अनंत-विकास परीक्षण में विफल रहता है।

— DLosc

यह सुनिश्चित करने के लिए एक उचित परिप्रेक्ष्य है। लेकिन भौतिक कंप्यूटर पर प्रोग्रामिंग भाषाओं का कार्यान्वयन उस परीक्षण को संतुष्ट नहीं करता है! अधिक से अधिक मेमोरी वाले भौतिक कंप्यूटर के अनुक्रम (काल्पनिक) अनुक्रम के साथ एक सामग्री हो सकती है, प्रत्येक उस कम्प्यूटेशनल फ़ंक्शन के एक और मूल्य की गणना करने में सक्षम है; उस बिंदु पर, हालांकि, किसी को इस तरह के GoL प्रोग्राम के इनपुट के (काल्पनिक) अनुक्रम के साथ समान रूप से सामग्री होनी चाहिए।

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

Answer 4

Turtlèd CT , 49 बाइट्स की व्याख्या करता है

मैं यह गोल्फ करने में सक्षम हो सकता है

इसके अलावा, यह उपयोगी कुछ भी उत्पादन नहीं करता है। यह सिर्फ और सिर्फ अगर दिए गए सीटी प्रोग्राम को रोकता है तो यह रुक जाता है।

यह वह है जिसे मैंने कुछ समय पहले वास्तव में बनाया था (तब कुछ अब गोल्फ हुआ)

!-l[*+.r_]' !l[ l]r[ u.(;d' u)d(1[ r].[ l])( r)+]

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

टर्टलड ग्रिड कोशिकाओं का उपयोग करता है। जब मैं कहता हूं "ग्रिड पर कुछ लिखो" तो मेरा मतलब है कि पात्रों का एक समूह समूह ग्रिड पर रखा गया है। उदाहरण

[ ][ ][ ][ ][ ][ ][ ]
[ ][H][E][L][L][O][ ]
[ ][ ][ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ][ ][ ]

कार्यक्रम पर

डेटा पहले इनपुट किया गया है:

!-l[*+.r_]' 

यह अनिवार्य रूप से एक बिल्ली कार्यक्रम है। यह ग्रिड पर इनपुट लिखता है।

तब आदेशों को इनपुट किया जाता है:

!

यह इन आदेशों के साथ क्या करता है:

ये कमांड "प्रोडक्शंस" हैं। यदि बाईं ओर डेटा बिट 1 है, तो यह डेटा स्ट्रिंग के अंत में उत्पादन की प्रतिलिपि बनाता है। अन्यथा कुछ नहीं होता। फिर सबसे बाएं डेटा बिट को हटा दिया जाता है, और यह अगले बाएं सबसे डेटा बिट के साथ अगले उत्पादन का उपयोग करता है। प्रोग्राम तब रुकता है जब डेटा स्ट्रिंग में कोई बिट्स नहीं होते हैं। इन प्रस्तुतियों को करने का एक तरीका अलग-अलग प्रस्तुतियों के बिट्स और अंत से निपटना है। यह हमारा कार्यक्रम है। यह अलग से बिट्स को डेटा स्ट्रिंग के अंत में कमांड स्ट्रिंग से कॉपी करता है, और अलग से डेटास्ट्रिंग से बिट्स को हटाता है

यह कार्यक्रम कैसे करता है। आदेशों को इनपुट करने के बाद, टर्टल / ग्रिड पॉइंटर, दास्तानस्ट्रिंग के सबसे बाईं ओर वापस चला जाता है। यह फिर एक लूप में जाता है

[ u.(;d' u)d(1[ r].[ l])( r)+]

यह इस लूप में क्या करता है, क्या यह बाईं ओर के डेटस्ट्रिंग से ऊपर जाता है, और वर्तमान कमांड कैरेक्टर (यू।) को लिखता है। यदि यह है;, एक उत्पादन का अंत, यह नीचे ले जाता है और इसके नीचे बाईं ओर के डेटा को हटाता है और वापस ऊपर ( (;d' u)) चलता है । फिर, किसी भी तरह से, यह एक ( d) नीचे चला जाता है । यदि बिट को हटाया नहीं गया था, तो इसका मतलब यह है कि यह जांचना होगा कि क्या अंत में कमांड से थोड़ा कॉपी करना है। इसलिए, यदि यह वर्ण जो सबसे बाईं ओर है या डेटाबेट 1 है, यह डेटा स्ट्रिंग के दाईं ओर के अंत में जाएगा, कमांड स्ट्रिंग से बिट की प्रतिलिपि बनाएँ, और बाईं ओर के डेटा के बाईं ओर के स्थान पर वापस जाएँ बिट ( (1[ r].[ l]))। अब, यह या तो सबसे बाईं डेटाबिट पर है, जो एक शून्य था, या सबसे बाईं डेटाबिट में से एक था। इसलिए, हम सही जगह पर चलते हैं (( r))। फिर, कमांड पॉइंटर को बढ़ाया जाता है, इसलिए हम अगले कमांड को लूप के अगले पुनरावृत्ति में लिखेंगे। यदि कोई अधिक डेटास्ट्रिंग नहीं है, तो इसका मतलब है कि हम एक स्थान पर होंगे और लूप समाप्त हो जाएगा। अन्यथा हम लूप को फिर से चलाते हैं।

Comments

यह और अधिक गोल्फ की कोशिश करो!

— अरोडेबाग

Answer 5

पर्ल → थ्री स्टार प्रोग्रामर वेरिएंट, 26 + 1 = 27 बाइट्स

++$a[$a[$a[$_]]]for@F;redo

इसे ऑनलाइन आज़माएं! (इस लिंक में एक शीर्ष लेख है जो पुनरावृत्तियों की एक निर्धारित संख्या के बाद कार्यक्रम से बाहर निकलता है (ताकि टीआईओ समय समाप्त न हो), और प्रत्येक पुनरावृत्ति को आंतरिक स्थिति मुद्रित करने के लिए (ताकि यह कुछ अवलोकन योग्य हो)।

-a(1 बाइट पेनल्टी के साथ दौड़ें, क्योंकि आप इसे -M5.010उत्पादन करने से पहले फिट कर सकते हैं -aM5.010)।

विशेष रूप से, यह तीन सितारा प्रोग्रामर को लागू करता है जिसमें कमांड को रिक्त स्थान द्वारा अलग किया जाता है और फ़ाइल में कोई टिप्पणी की अनुमति नहीं है, बिना I / O एक्सटेंशन। (इन परिवर्तनों से भाषा की ट्यूरिंग-पूर्णता पर कोई फर्क नहीं पड़ता, जाहिर है।) थ्री स्टार प्रोग्रामर के लिए ट्यूरिंग-पूर्णता का कोई प्रमाण ऑनलाइन नहीं है, लेकिन यह ट्यूरिंग-पूर्ण है (मैं इसके ट्यूरिंग का एक स्केच प्रमाण साझा कर रहा हूं। -अन्य esoprogrammers के साथ अपूर्णता, लेकिन जब मुझे पता चला कि आपने वास्तव में मूल झटके पर काबू पा लिया था, तो यह प्रोग्राम में वास्तव में काफी आसान था।

कार्यक्रम को वास्तव में बहुत स्पष्टीकरण की आवश्यकता नहीं है; थ्री स्टार प्रोग्रामर का एक बहुत ही सरल विनिर्देश है, और यह इसका सीधा अनुवाद है। एकमात्र सूक्ष्म बिंदु: @Fसरणी रूप में कार्यक्रम के लिए इनपुट है (यह एक परिणाम है -a); और redoपूरे कार्यक्रम को दोहराएंगे क्योंकि यह एक निहित लूप (भी एक परिणाम -a) है।

Comments

मुझे लगता है कि तीर का मतलब "व्याख्या" की तुलना में कम हो गया है।

— क्विंटोपिया

Answer 6

x86 असेंबली (इंटेल सिंटैक्स / MASM) -Brainfuck 2127 बाइट्स।

अभी भी गोल्फ सक्षम है

.386
.model flat,stdcall
.stack 4096
include \masm32\include\masm32.inc
includelib \masm32\lib\masm32.lib
ExitProcess proto,dwExitCode:dword
.data
bfsrc BYTE 200 dup(0) 
bfcells BYTE 100 dup(0) 
loopStack DD 5 dup(0) 
charBuf BYTE 5 dup(0) 
newline BYTE 10,0 
prompt BYTE "$",0 
hr BYTE 50 dup('-'),0 
space BYTE ' ',0
.code
EvalBf proc
    start:
    invoke StdOut, addr prompt
    invoke StdIn, addr bfsrc,200
    cmp bfsrc,0
    je exit
    mov eax,0 
    mov ebx,0 
    mov ecx,0 
    processInstruction:
    cmp BYTE PTR bfsrc[ebx], '+'
    je plus
    cmp BYTE PTR bfsrc[ebx], '-'
    je minus
    cmp BYTE PTR bfsrc[ebx], '>'
    je fwd
    cmp BYTE PTR bfsrc[ebx], '<'
    je back
    cmp BYTE PTR bfsrc[ebx], '['
    je open
    cmp BYTE PTR bfsrc[ebx], ']'
    je close
    cmp BYTE PTR bfsrc[ebx], '.'
    je dot
    jmp processNextInstruction
    plus:
    inc BYTE PTR bfcells[eax]
    jmp processNextInstruction
    minus:
    dec BYTE PTR bfcells[eax]
    jmp processNextInstruction
    fwd:
    inc eax
    jmp processNextInstruction
    back:
    dec eax
    jmp processNextInstruction
    open:
    mov loopStack[ecx*4],ebx
    inc ecx
    jmp processNextInstruction
    close:
    dec ecx
    cmp BYTE PTR bfcells[eax], 0
    je processNextInstruction
    mov ebx,loopStack[ecx*4]
    inc ecx
    jmp processNextInstruction
    dot:
    mov dl, BYTE PTR bfcells[eax]
    mov BYTE PTR charBuf[0], dl
    mov BYTE PTR charBuf[1],0anything
    push eax
    push ecx
    invoke StdOut, addr charBuf
    pop ecx
    pop eax
    jmp processNextInstruction
    processNextInstruction:
    inc ebx
    cmp BYTE PTR bfsrc[ebx], 0
    je done
    jmp processInstruction
    done:
    invoke StdOut, addr newline
    mov eax, 0
    printNext:
    cmp eax, 100
    jge reset
    push eax
    invoke dwtoa, BYTE PTR bfcells[eax], addr charBuf
    invoke StdOut, addr charBuf
    invoke StdOut, addr space
    pop eax
    inc eax
    jmp printNext
    reset:
    invoke StdOut, addr newline
    invoke StdOut, addr hr
    invoke StdOut, addr newline
    jmp start

    exit:
    invoke ExitProcess,0
EvalBf endp
end EvalBf

Comments

आमतौर पर असेंबली के उत्तर को परिणामी मशीन कोड के आकार में गिना जाता है, इसलिए आपको असेंबली को गोल करने की ज़रूरत नहीं है, बस निर्देशों की संख्या / आकार को कम से कम करें।

— रॉबर्ट फ्रेजर

@RobertFraser उह मैं नहीं जानता कि कैसे गिनती की जाए: पी

— क्रिस्टोफर

दरअसल, सबसे पहले मैंने किसी तरह शीर्षक को "ब्रेनफक में लागू किया गया x86 asm" के रूप में पढ़ा था और थोड़े प्रभावित हुए थे :)

— quetzalcoatl

@Quetzalcoatl प्रभावशाली होगा

— क्रिस्टोफर

pls गोल्फ चर / लेबल नाम ty

— केवल

Answer 7

पिप की व्याख्या चक्रीय टैग सिस्टम , 16 बाइट्स

YqWyyPBg@++vXPOy

टैग सिस्टम के प्रोडक्शंस को कमांड-लाइन आर्ग्यूमेंट्स और स्टड से प्रारंभिक डेटा स्ट्रिंग के रूप में लेता है।

उपरोक्त कोड को सत्यापित करना कठिन है क्योंकि यह किसी भी आउटपुट का उत्पादन नहीं करता है (इसलिए केवल अवलोकन योग्य व्यवहार "समाप्त होता है" बनाम "समाप्त नहीं होता है")। इसलिए, यहां एक अनगुल्ड संस्करण है जो प्रत्येक चरण के बाद डेटा स्ट्रिंग को आउटपुट करता है, और 20 चरणों के बाद भी समाप्त हो जाता है, इसलिए TIO को अनंत लूप से आउटपुट के टन से निपटने की आवश्यकता नहीं है: इसे ऑनलाइन आज़माएं!

चक्रीय टैग सिस्टम

चक्रीय टैग प्रणाली एक अत्यंत सरल अभी तक ट्यूरिंग-पूर्ण कम्प्यूटेशनल मॉडल है। वे प्रस्तुतियों की एक सूची से युक्त होते हैं जो डेटा स्ट्रिंग पर संचालन को परिभाषित करते हैं । प्रोडक्शंस और डेटा स्ट्रिंग में 1 और 0 शामिल हैं।

प्रत्येक चरण में, डेटा स्ट्रिंग के सबसे बाएं वर्ण को हटा दिया जाता है।

• यदि चरित्र 1 है, तो वर्तमान उत्पादन डेटा स्ट्रिंग के दाईं ओर जोड़ा जाता है।
• यदि वर्ण 0 है, तो कुछ भी जोड़ा नहीं जाता है।

या तो मामले में, वर्तमान उत्पादन सूची में अगले उत्पादन तक जाता है, चक्रीय रूप से: यदि हम पिछले उत्पादन में थे, तो हम पहले के आसपास लूप करते हैं। डेटा स्ट्रिंग खाली होने तक निष्पादन जारी रहता है।

व्याख्या

                  g is list of cmdline args; v is -1 (implicit)
 q                Read a line of stdin for the data string
Y                 and yank it into the y variable
  Wy              While data string is nonempty:
       g@++v       Retrieve the next production from g (using cyclic indexing)
             POy   Pop the first character of y
            X      String-multiply: result is the production if the first character of y
                   was 1, or empty string if it was 0
    yPB            Push that string to the back end of y

Comments

हे, मुझे अभी याद आया कि आपको डेटा स्ट्रिंग इनपुट करने की आवश्यकता नहीं है; यह सिर्फ किया जा सकता है 1इस के लिए esolangs लिंक: स्रोत arxiv.org/abs/1312.6700 । मैं जल्द ही अपने उत्तर को संपादित करूंगा, और अगर इससे आपको अपने उत्तर में मदद मिलती है (जैसा कि आपका इनपुट वास्तव में पर्याप्त गोल्फ लगता है)

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

Answer 8

Iterated सामान्यीकृत Collatz कार्य -> पायथन 2, 46 बाइट्स

a,b,x,m=input()
while-~x%m:x=x/m*a[x%m]+b[x%m]

इस फ़ंक्शन को m-1 a और b की सूचियों, शुरुआती मूल्य x और भाजक m के साथ कॉल करें, जो सामूहिक रूप से IGCF के लिए "प्रोग्राम" का गठन करता है। संकेत करने के लिए कि कौन से मोडुली को रुकने के लिए तीसरा सरणी लेने के बजाय, यह तब मापता है जब भी मापांक m-1 है। इस सरलीकरण का अर्थ है कि दिए गए फ्रैक्ट्रन कार्यक्रम को इस प्रकार में परिवर्तित करने में कुछ अतिरिक्त प्रयास हो सकते हैं, लेकिन यह दुभाषिया में कुछ बाइट्स को बचाता है।

इसे ऑनलाइन आज़माएं! यह TIO दर्शाता है कि इस भाषा के साथ 5 + 5 कैसे जोड़ा जाए। कार्यक्रम a = [3], b = [0], m = 2 करता है, और 7776 = 2 ^ 5 * 3 ^ 5 के साथ शुरू होकर अंततः 59049 = 3 ^ 10 प्राप्त होता है।

Comments

डांग अच्छा काम है। मैं बाउंटी लेकिन अच्छी नौकरी जीतने की उम्मीद कर रहा था

— क्रिस्टोफर

Answer 9

रिस्पांसिबल संस्करण -> पायथन 2, 47 बाइट्स

l=input()
while l:l=l[2+l[0]:]+l[2:2+l[0]]*l[1]

यह फ़ंक्शन ResPlicate के एक प्रकार की व्याख्या करता है

• जिसके लिए एक कार्यक्रम भी सूचकांकों पर समान तत्वों के साथ समान लंबाई की एक अजगर सूची है।
• नहीं I / O के साथ।
• जिसके लिए कतार के शेष भाग में मौजूद मानों की तुलना में अधिक मानों को कॉपी करने की कोशिश की जाती है, बस शेष कतार को कॉपी करता है (यानी, कॉपी की गई बिट को आवश्यक लंबाई के साथ शून्य नहीं किया जाता है)।

अंतिम परिवर्तन का मतलब है कि कुछ ResPlicate प्रोग्राम (जो पहली शर्त को पूरा करते हैं) इस संस्करण में समान व्यवहार नहीं करेंगे, लेकिन सौभाग्य से, BCT दुभाषियों को हटाए गए कार्यक्षमता की आवश्यकता नहीं है, और इसलिए भाषा टीसी बनी हुई है।

इसे ऑनलाइन आज़माएं! इस TIO में यह दिखाने के लिए एक प्रिंट है कि यह काम करता है और एक हेडर जो 1 सेकंड के बाद प्रोग्राम को मारता है और एक उदाहरण जो TIO की तुलना में अधिक आउटपुट उत्पन्न करने का प्रबंधन करता है, वह एक सेकंड में संभाल सकता है।

Comments

क्यों नहीं l=input()? एक बाइट कम होगी।

— feersum 8'17

Answer 10

पर्ल -a → आई / डी मशीन , 24 बाइट्स

$p=$a[$p]+=$_ for@F;redo

इसे ऑनलाइन आज़माएं! (इसमें एक हेडर होता है जो आंतरिक स्थिति को प्रिंट करता है और 10 पुनरावृत्तियों के बाद रुकता है, ताकि व्यवहार अवलोकन योग्य हो)

भाषा के बारे में

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

केवल दो आदेश हैं:

• I: सेल डेटा सूचक को बढ़ाता है। (डेटा पॉइंटर ही अपरिवर्तित रहता है।)
• D: डेटा पॉइंटर को डिरेल करें, अर्थात उस सेल के मान को पढ़ें जो डेटा पॉइंटर को इंगित करता है। फिर परिणामी मूल्य को संग्रहीत करें जिसे आप डेटा पॉइंटर में वापस पढ़ते हैं।

निष्पादन बस प्रोग्राम को एक लूप में बार-बार, हमेशा के लिए चलाता है।

यह काफी आश्चर्यजनक है कि यह सरल भाषा ट्यूरिंग-पूर्ण है, इसलिए मैं यह साबित करने पर काम कर रहा हूं। यहाँ सबूत है । यह थ्री स्टार प्रोग्रामर के लिए (लेकिन इससे भी सरल) प्रमाण के समान है, एक बहुत ही समान भाषा है (और वास्तव में, यह सबमिशन प्रोग्राम के चारों ओर एक ही मूल OISC "शेल" का उपयोग करता है, केवल वास्तविक निर्देशन में भिन्न होता है)।

कार्यक्रम के बारे में

प्रयोग

इनपुट को मानक इनपुट पर दिया जाना चाहिए, और टिप्पणियों के बिना एक I / D मशीन प्रोग्राम है, और RLE / OISC सिंटैक्स का उपयोग कर रहा है। (I / D मशीन में दो अलग-अलग, समान वाक्यविन्यास हैं, लेकिन गोल्फ के लिए यह कार्यक्रम केवल उनमें से एक का समर्थन करता है।) इस वाक्यविन्यास में, एक प्रोग्राम दशमलव में संख्याओं का एक क्रम है, Iजो Dकमांड के बीच कमांडों की लंबाई का प्रतिनिधित्व करता है । (आप उनके बीच D"रन ऑफ़ 0 Iकमांड" रखकर दो या अधिक लगातार कमांड निर्दिष्ट कर सकते हैं , इसलिए वाक्यविन्यास पूरी तरह से सामान्य है।)

व्याख्या

कार्यक्रम से देखा जा सकता है, इस को लागू नहीं किया गया है Iऔर Dआदेशों को व्यक्तिगत रूप से। वास्तव में, यह एक (बहुत थोड़ा) दुभाषिया का अनुकूलन है (विशुद्ध रूप से क्योंकि यह इस तरह से लिखना छोटा है)। यह देखना है कि एन इंक्रीमेंट कमांड का एक रन डेटा पॉइंटर के टारगेट को एन बार बढ़ाता है , यानी इसमें एन जोड़ें ; और 0 इंक्रीमेंट कमांड का रन भी इस तरह से लागू किया जा सकता है, क्योंकि 0 को मेमोरी में जोड़ने से कोई प्रभाव नहीं पड़ता है। इसलिए जो ऑपरेशन हम वास्तव में कार्यान्वित करते हैं वह एक रन-इन Iऔर ए को लागू करने के बीच वैकल्पिक करना है D। या दूसरे शब्दों में, " एन जोड़ेंडेटा पॉइंटर द्वारा इंगित मूल्य (डेटा पॉइंटर द्वारा इंगित मूल्य में इसे वापस संग्रहीत करना), फिर डेटा पॉइंटर द्वारा इंगित मूल्य को पढ़ें और इसे डेटा पॉइंटर में संग्रहीत करें "। यह स्पष्ट रूप से इसके मुकाबले अधिक क्रिया है। होने के लिए, और हम इसे " डेटा पॉइंटर द्वारा इंगित मूल्य में n को जोड़ने के लिए आगे सरलीकृत कर सकते हैं , फिर उस मूल्य को डेटा पॉइंटर के लक्ष्य और स्वयं डेटा पॉइंटर दोनों में संग्रहीत कर सकते हैं"।

तो यह हमारे कार्यक्रम के मूल के लिए बनाता है। हम $aरैम को स्टोर करने के लिए एक सरणी का उपयोग कर रहे हैं , और $pडेटा पॉइंटर के रूप में (सरणी में अनुक्रमण कर रहे हैं):

$p=$a[$p]+=$_
         + $_  add {the run length}
   $a[$p]      to the element of $a pointed to by $p
   $a[$p] =    storing the result back into that element
$p=            and also in the pointer itself

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

अंत में, हमें यह करने की आवश्यकता है कि इस कार्यक्रम को दो छोरों में रखा जाए। for@Fपाश, के साथ संयुक्त -aकमांड लाइन विकल्प, मानक इनपुट के क्षेत्र से अधिक इच्छा लूप ( "क्षेत्र" के डिफ़ॉल्ट परिभाषा यहाँ खाली स्थान के पर विभाजित होगा)। redoपाश एक अंतर्निहित पाश में पूरे कार्यक्रम (अलावा अन्य, आसानी से, मानक इनपुट के पढ़ने) स्थापित करेंगे, जो के रूप में मैं / डी मशीन के शब्दों के लिए आवश्यक कार्यक्रम बार-बार एक पाश में चलाने के लिए, कारण होगा।

Comments

वापसी पर स्वागत है! हमें अब दुभाषियों के लिए झंडे लगाने की ज़रूरत नहीं है, बस ध्यान दें कि यह 'पर्ल के साथ -a' है। codegolf.meta.stackexchange.com/a/14339/9365

— डोम हेस्टिंग्स

Answer 11

जेली → 2-टैग प्रणाली , 8 बाइट्स

µḢị⁴⁸;Ḋß

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

मेरे पास व्यावहारिक भाषाओं के पक्ष में जाने वाली एक इनाम है, लेकिन मुझे लगा कि मैं मूल कार्य को जीतने की कोशिश कर सकता हूं जबकि मैं इस पर था (जैसा कि मैं वास्तव में अपना इनाम नहीं जीत सकता)।

ट्यूल पूर्णता के लिए आवश्यक नहीं के रूप में टैग सिस्टम का एक संस्करण लागू करता है, जिसमें कोई रुकावट नहीं है। राज्यों की संख्या 1 से, लगातार, और प्रारंभिक स्ट्रिंग कार्यक्रम से पहले आती है।

उदाहरण के लिए, विकिपीडिया एक टैग प्रणाली का एक उदाहरण देता है { a, b, c}, { a→ bc, b→ a, c→ aaa} प्रारंभिक तार के साथ aaa; इस इनपुट प्रारूप में, यह [1,1,1], है [[2,3],[1],[1,1,1]]। (टैग सिस्टम में एक निश्चित सिंटैक्स नहीं है, और यह ऐसा करने के लिए एक उचित तरीका लगता है।)

यह Ṅदिखाने के लिए कि कार्यक्रम वास्तव में काम कर रहा है, TIO लिंक में एक जोड़ा गया है ("आंतरिक स्थिति और stdout के लिए एक नई पंक्ति लिखें")।

व्याख्या

µḢị⁴⁸;Ḋß
           {implicit: initialise internal state from first argument}
µ          Disregard the second command-line argument by default
 Ḣ         Take the first element, removing it from the internal state
  ị⁴       Use the value to index into the second argument
    ⁸;     Prepend (the rest of) the internal state
      Ḋ    Discard the first element of the internal state
       ß   Loop forever

Answer 12

बीएफ / पी "एक ट्यूरिंग मशीन, 842 बाइट्स में लागू किया गया

संक्रमण तालिका (लंबाई के कारण लिंक की गई)

संक्रमण तालिका, कम गोल्फ वाला संस्करण

ट्यूरिंग मशीन सिम्युलेटर मैंने इस्तेमाल किया

यह निश्चित रूप से लंबाई के लिए किसी भी पुरस्कार को जीतने के लिए नहीं है, लेकिन यह कुछ ऐसा है जो मैं हमेशा से करना चाहता था, क्योंकि बीएफ एक ट्यूरिंग मशीन के समान है। प्रत्येक सेल से एक मान संग्रहीत करता है 0x0- 0xF। चौड़ाई हालांकि अभी तक ट्यूरिंग मशीन वेबसाइट आपके ब्राउज़र को क्रैश किए बिना जा सकती है। ,और .कार्य (इनपुट और आउटपुट) परिभाषित नहीं कर रहे हैं, तो यह थोड़ा और पी "सच बीएफ से की तरह है।

इसे चलाने के लिए, संक्रमण तालिका को ट्यूरिंग मशीन सिम्युलेटर में पेस्ट करें, इनपुट को कुछ बीएफ कोड पर सेट करें, और रन दबाएं।

टीएम का टेप बीएफ कोड और बीएफ डेटा दोनों को बीच में एक सिंगल स्पेस के साथ स्टोर करता है। यह कोड में वर्तमान में चल रहे चरित्र को संशोधित करके ( [-> (, आदि) और ^सेल के सामने डेटा में इसकी स्थिति को ट्रैक करता है। एक बार जब यह एक कमांड कैरेक्टर पढ़ता है, तो यह तब तक चलता है जब तक यह कैरेट को हिट नहीं करता है, एक सेल को दाईं ओर ले जाता है, और उपयुक्त फ़ंक्शन करता है। फिर यह बीएफ कोड में "संशोधित" कमांड वर्णों में से एक की तलाश में वापस चला जाता है, और पूरी प्रक्रिया को दोहराते हुए अगले पर जाता है। एक बार जब यह कोड से बाहर हो जाता है, तो यह रुक जाता है।

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

गोल्फ और ungolfed संस्करण बिल्कुल समान हैं कि वे कैसे काम करते हैं, लेकिन ungolfed संस्करण में अधिक मानव-अनुकूल नाम हैं और खंडों में टूट गया है।

Comments

संक्रमण तालिका फिट करने के लिए पोस्ट की लंबाई सीमा पर्याप्त से अधिक है

— ASCII-only

Answer 13

सी (2,3) ट्यूरिंग मशीन को लागू करना , 236 205 बाइट्स ( 46 31 कम यदि आप अजीब इनपुट के बारे में परवाह नहीं करते हैं)

-11 बाइट्स के लिए ऐपलेशेल के लिए धन्यवाद, -12 बाइट्स के लिए विजुअलमेलन और -7 बाइट्स के लिए जोहान डू टॉयट।

CeilingCat ने एक संस्करण बनाया जो केवल 144 बाइट्स का उपयोग करता है, यहां देखें ।

(मैंने यहां कुछ पंक्ति विराम जोड़े हैं ताकि आपको स्क्रॉल न करना पड़े, लेकिन आम तौर पर उनमें से अधिकांश को हटा दिया जाएगा)

#define c char
j;i;k;c s,d[256];c main(){c*p=d+128;gets(d);
for(;k<256&&d[k];)d[k++]-=48;for(;++j<256;)
{c t=*p;*p=-t*t+(2-s)*t+1+s;p+=(s^t==0)*2-1;s=s?t%2:!t%3;
for(i=0;++i<256;)printf("%d",d[i]);puts("");}}

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

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

यह एक बहुत लंबी प्रविष्टि है, लेकिन यह मेरा पहली बार है जब मैं इनमें से एक कर रहा हूं और मैंने एक समर्पित गोल्फिंग भाषा का उपयोग नहीं किया है। मुझे बहुत मज़ा आया, भले ही यह मेरी अपेक्षा से अधिक लंबा हो।

बहुत सारे बाइट्स इनपुट और आउटपुट से निपटने के हैं, और मैंने NUL, SOH, STX के बजाय 0, 1, और 2 को स्वीकार करके पूरे 42 बाइट खो दिए। (इसे बदलने के लिए, k;सामने for(;k<256&&d[k];)d[k++]-=48;से और दूसरी पंक्ति से हटाएं ।)

संक्रमण तालिका, विशेष रूप से लाइन *p=-t*t+(2-s)*t+1+s;(जो टेप पर मान सेट करती है) को संभवतः अधिक संकुचित किया जा सकता है।

Comments

वाह, और यह यहाँ आपका पहला कोड गोल्फ है! आश्चर्यजनक!

— ज़चारि

आप इस तरह के वैश्विक परिवर्तनीय घोषणाओं को छोटा कर सकते हैं: k,j;c s,d[256];( intसी में निहित है, तो आप i3 बाइट्स को बचाने के लिए वैश्विक घोषणा पर भी आगे बढ़ सकते हैं )

— अप्रेल

@Appleshell धन्यवाद, मैं ऐसा करूँगा।

— --५

आप लूप के लिए स्ट्रिंग नल-टर्मिनल चेक को अंदर ले जा सकते हैं। इन-अस्तर k++और हटाने {}कुछ और बाइट्स की बचत होती है: for(;k<256&d[k];)d[k++]-=-48;क्योंकि j(मूल्य का इस्तेमाल कभी नहीं) क्या आप इसे बदलना कर सकते हैं (और सिर्फ एक टाइमकीपर है i) के साथ kपीछे की ओर की गणना के द्वारा: क्या आप जानते k==256पहली पाश के बाद, तो दूसरे में शून्य करने के लिए उलटी गिनती for(;k>0;), जो छोड़ देता है k==-1, इसलिए अंतिम लूप बन सकता है for(;++k<256;)। (डिस्क्लेमर: मैं आमतौर पर गोल्फ खेलता हूं C#, लेकिन ऐसा लगता है कि संकलन)।

— विजुअलमेल

@VisualMelon मैंने समस्या का निर्धारण किया। मुझे उपयोग करने की आवश्यकता थी k<256&&d[k], न कि &, क्योंकि d[k]इसका मूल्यांकन किया जा रहा था k==256। इसके अलावा, चूंकि उस लूप के बाद kहोने की कोई गारंटी नहीं थी , इसलिए 256मुझे 256 चरणों की गारंटी देने के लिए इसे बाद में रीसेट करना पड़ा। (यदि आप (VisualMelon) के पास कोई अन्य सुझाव है, तो हमें संभवतः उन्हें चैट में डाल देना चाहिए ताकि हमें बहुत अधिक टिप्पणियां न मिलें)

— a52

Answer 14

रोड़ा फ्रैक्ट्रन को लागू करते हुए , 114 112 106 बाइट्स

1 बाइट ने मापदंडों को फिर से व्यवस्थित करके @fergusq के लिए धन्यवाद बचाया

f&n,a{x=1{x=0;(a/" ")()|[_/`/`]|[parseInteger(_[0],_1[1])]|{|q,w|{n*=q/w;x=1}if[n%w<1,x<1]}_,_}while[x>0]}

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

फ़ंक्शन को कॉल करें जैसे f reference_to_input program:। के स्थान पर आउटपुट संग्रहीत किया जाएगा input।

Comments

के बाद अर्धविराम e[1]बेमानी है। इसके अलावा आप पैरामीटर आदेश को बदलकर एक बाइट बचा सकते हैं f&n,a:।

— फर्ग्यूसक

@fergusq f&n,aचाल के लिए धन्यवाद , और जब आप टिप्पणी कर रहे थे तो मैं उस अर्ध-

— उपनिवेश

Answer 15

क्लोजर, 82 81 बाइट्स (ट्यूरिंग मशीन)

अद्यतन: से एक स्थान हटाया गया t{} s।

#(loop[p 0 t{}s 1](if-let[[S M N](%[(or(t p)0)s])](recur(+ p M)(assoc t p S)N)t))

ट्यूरिंग मशीन को लूप के रूप में लागू करता है, जब हॉल्टिंग अवस्था में पहुँच जाता है तो टेप लौटाता है। राज्य संक्रमण नियमों में यह संक्रमण राज्य को ommitting द्वारा इंगित किया गया है। यह settins Nकरने nilऔर बाद में if-letइसी राज्य संक्रमण के रूप में रद्द कर देगा इनपुट हैश नक्शे से नहीं मिला है %। वास्तव में इस राज्य के लिए कोई भी मूल्य होगा, जैसे कि :abort, 0 या -1।

से एक उदाहरण 3-राज्य 2-प्रतीक व्यस्त बीवर के साथ Ungolfed विकिपीडिया ।

(def f #(loop[pos 0 tape {} state 1]
          (if-let [[sym move next-state](%[(get tape pos 0)state])]
            (do (println [pos tape state])
                (recur(+ pos move)(assoc tape pos sym)next-state))
            tape)))

(f {[0 1] [1  1 2]
    [0 2] [1 -1 1]
    [0 3] [1 -1 2] 
    [1 1] [1 -1 3]
    [1 2] [1  1 2]
    [1 3] [1  1]})

{0 1, 1 1, -1 1, -2 1, -3 1, 2 1}

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

6700K के एकल कोर पर यह 5-राज्य 2-प्रतीक व्यस्त बीवर (47.1 मिलियन चरणों) को लगभग 29 सेकंड या 1.6 मिलियन चरणों / सेकंड में चलाता है।

Answer 16

एम → टिप , 4 बाइट्स

Ṅ×ịß

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

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

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

ı$i=\sqrt{-1}$

I / O (हॉल्ट / नो-हाल्ट के अलावा) लागू नहीं करता है। I / O टिप (भाषा का हिस्सा नहीं है) के लिए एक एक्सटेंशन है, और ट्यूरिंग-पूर्णता के लिए आवश्यक नहीं है।

स्पष्टीकरण / पृष्ठभूमि

Ṅ×ịß
Ṅ     Print {the left argument} and a newline; also resolves a parser ambiguity
  ị   {The left argument}th element of {the right argument}, wrapping on OoB
 ×    Multiply {the left argument} by {the chosen element}
   ß  Recursive call; arguments: {the product} and {the same right argument}

[1,2,3][1,2,3,1,2,3,1,2,3,…]$rx+s$, जो एक बहुपद है, और "आधार रूपांतरण" बिलिन है कि कई गोल्फिंग भाषाओं में वास्तव में भेस में एक सामान्य-उद्देश्य बहुपद मूल्यांकनकर्ता है। इसलिए हम सभी को अंकों की सूचियों की सूची में अनुक्रमित करना है, उन्हें आधार-रूपांतरित करना है और हम कर रहे हैं, है ना?

$x$$x$

ḅ$x\oplus(x\otimes y)$$x\otimes y$${\oplus}$। यकीन है, हम बहुत कुछ भी हम चाहते हैं, लेकिन हम एक पूरी बाइट खर्च होंगे, और इस सवाल के लिए गोल्फ भाषा प्रविष्टियों इतनी छोटी हो रही है कि एक बाइट बहुत कुछ है।

इसलिए मैंने पीछे मुड़कर देखा और थोड़ा मूल्यांकन किया। क्या बहुपद मूल्यांकन के बजाय हम कोई भी संचालन कर सकते हैं? आदर्श रूप से, जो कि सराहनीय हैं, इसलिए हमें तर्क क्रम के बारे में चिंता करने की ज़रूरत नहीं है? इसके तुरंत बाद, मुझे एहसास हुआ कि Collatz फ़ंक्शंस उनके मुकाबले अधिक जटिल हैं।

$s$

और निश्चित रूप से, आधार रूपांतरण ( ḅ) के विपरीत , गुणन ( ×) सराहनीय है, और इस तरह यह मायने नहीं रखता कि तर्क किस क्रम में रखे गए हैं। इसलिए हम सभी को लिखने की आवश्यकता है ×ịऔर फिर कार्यक्रम को एक अनंत पुनरावृत्ति में रखें ß। और हमारे पास एक ट्यूरिंग-पूर्ण भाषा है। सही?

$(x\odot y)\oplus(x\otimes y)$¹×ịß¹¹Ṅ एक अच्छा विकल्प है क्योंकि यह उपयोगी डिबग आउटपुट का उत्पादन करता है।

क्या तीन बाइट्स संभव है? जब तक मैं कुछ याद नहीं कर रहा हूं, तो भाषा को लागू करने और लागू करने के इस विशिष्ट विकल्प के साथ नहीं, लेकिन इस बिंदु पर यह निश्चित रूप से ऐसा लगता है कि यह किसी भी तरह संभव होगा, क्योंकि इसे चार में करने के लिए बहुत सारे तरीके हैं और बहुत सारे ट्यूरिंग-पूर्ण आप जिन भाषाओं को लागू कर सकते हैं।

Comments

इस बारे में कुछ और सोचने के बाद, हम इसे तीन बाइट्स का उपयोग करके प्राप्त कर सकते हैं ḋऔर ṙइसके बजाय ×और ị; परिणामी भाषा टिप के समान भाषा नहीं है, लेकिन यह काफी समान है और लगभग निश्चित रूप से एक ही कारण के लिए ट्यूरिंग-पूर्ण है। दुर्भाग्य से, ḋएम में कार्यान्वित नहीं किया गया है, और जब जूलर्स गैर-पूर्णांक वास्तविक संख्या है, तो मैं जेली को मनमाने ढंग से सटीक गणना करने का कोई तरीका नहीं खोज सकता। यदि किसी को कोई अन्य गोल्फ भाषा पता है, जहां यह निर्माण कार्य हो सकता है, हालांकि, इसे जाने के लिए स्वतंत्र महसूस करें।

— अनीस 523

Answer 17

सी, ब्रेनफॉक की व्याख्या, 187 बाइट्स

t[999],*p=t,c,i,l;f(char*t){for(i=0;c=t[i];i++){c^62?c^60?c^43?c^45?c^46?c^44?c^91:(*p=getchar()):putchar(*p):--*p:++*p:--p:++p;if(c==93&&*p)for(l=1;l>0;)c=t[--i],c==91?l--:c==93?l++:0;}}

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

Comments

वेल्ड, बीएफ का उपयोग कर एक उत्तर होने के लिए बाध्य था।

— ज़ाचारि

Answer 18

लुआ ने ब्रेनफ ***, 467 बाइट्स की व्याख्या की

b,r,a,i,n,s=0,io.read,{0},1,1,"><+-.,[]"c,f=r(),{function()n=n+1;a[n]=a[n]or 0;end,function()n=n-1;a[n]=a[n]or 0;end,function()a[n]=a[n]+1;end,function()a[n]=a[n]-1;end,function()io.write(string.char(a[n]))end,function()a[n]=io.read():byte()end,function()i=a[n]~=0 and i or c:find("]",i)end,function()if a[n]~=0 then b,x=1,""repeat i=i-1 x=c:sub(i,i)b=x=="["and b-1 or x=="]"and b+1 or b until b==0 and x=="["end end}repeat f[s:find(c:sub(i,i),1,1)]()i=i+1 until i>#c

मुझे पता है कि अभी भी कुछ मंदी है जो मैं बाद में कर सकता हूं, लेकिन यहां मेरा पहला पास समाप्त हो गया है। मानक इनपुट से ब्रेनफ कोड लेता है।

Comments

+1 के लिए brains, यह हमेशा मजेदार होता है जब गोल्फर चर की सूची में असाइन होते हैं।

— ज़ाचारि

Answer 19

सीजेएम → रिस्पांसिबल वेरिएंट, 15 14 13 बाइट्स

^{-1 बाइट @ ais523 के लिए धन्यवाद}

l~{(/((*+e_}h

इस उत्तर में वैरिएंट एक जैसा है , सिवाय इसके कि कतार से हटाए गए आइटम की संख्या कतार पर शीर्ष संख्या से एक कम है।

l~{ ... }hहिस्सा सिर्फ इनपुट के रूप में एक सरणी लेता है और जब तक कि सरणी रिक्त है दोहराता है।

मुख्य लूप के लिए स्पष्टीकरण:

    e# Stack:             | [3 2 1 1 2 2 2 1]
(   e# Pop first element: | [2 1 1 2 2 2 1] 3
/   e# Split chunks:      | [[2 1 1] [2 2 2] [1]]
(   e# Pop first:         | [[2 2 2] [1]] [2 1 1]
(   e# Pop first:         | [[2 2 2] [1]] [1 1] 2
*   e# Repeat array:      | [[2 2 2] [1]] [1 1 1 1]
+   e# Concatenate:       | [[2 2 2] [1] 1 1 1 1]
e_  e# Flatten:           | [2 2 2 1 1 1 1 1]

Comments

आपको वास्तव में यहां वेतन वृद्धि की आवश्यकता नहीं है। बस निर्दिष्ट करें कि मूल कार्यक्रम में ब्लॉक की लंबाई 1 से बढ़ाई जानी चाहिए; यह ResPlicate के ट्यूरिंग-पूर्णता को नुकसान नहीं पहुंचाता है (टीसी निर्माण हैं जिसमें ब्लॉक लंबाई और दोहराने की गिनती कभी एक दूसरे के साथ मिश्रित नहीं होती हैं)।

Answer 20

चिप , 20 + 3 = 23 बाइट्स (नियम 110)

AZZ
>}/a
`)\'E~Zte*f

झंडे के लिए +3 -z

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

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

यह कार्यान्वयन इनपुट और दिए गए आउटपुट ASCII 0s और 1s के रूप में लेता है । यहाँ तर्क निम्नानुसार है:

p := value of left neighbor cell    AZZ
q := value of current cell          AZ
r := value of right neighbor cell   A

q' := ((r xor q) and p) or          >}/a
      ((r or q) and ~p)             `)\'

शेष तत्व हाउसकीपिंग के लिए हैं: e*fASCII अंक आउटपुट का कारण बनता है, और E~Ztइनपुट समाप्त होने के बाद निष्पादन को दो बाइट्स समाप्त करता है (चूंकि चौड़ाई प्रत्येक पीढ़ी 2 से बढ़ती है)।

Answer 21

क्लोजर, 75 बाइट्स (चक्रीय टैग प्रणाली)

अद्यतन 1: के some?साथ बदल दिया nil?।

अद्यतन 2: की एक Sऔर शाखा में एक लापता फिक्स्ड if s।

#(loop[[p & P](cycle %)[s & S]%2](if(nil? s)S(recur P(if s(concat S p)S))))

चक्रीय टैग प्रणाली को लागू करता है , nilयदि प्रोग्राम रुकता है, तो हमेशा के लिए अन्यथा लूप। क्लोजर वास्तव में यहां अनंत आलसी दृश्यों (जैसे चक्र ) और विनाशकारी के साथ चमकता है । प्याज और शून्य को सच्चे और झूठे मूल्यों के रूप में इंगित किया जाता है। जब डेटा स्ट्रिंग रन आउट sहो जाता है nil।

Ungolfed:

(def f #(loop[[p & P] (cycle %) [s & S] %2 i 5]
          (do
            (pprint [p (concat [s] S)])
            (if (and (some? s) (pos? i))
              (recur P (if s (concat S p) S) (dec i))))))

उदाहरण के परिणाम:

(f [[false]] [true true])
[[false] (true true)]
[[false] (true false)]
[[false] (false false)]
[[false] (false)]
[[false] (nil)]

(f [[false true true] [true false] [true false true]] [true])
[[false true true] (true)]
[[true false]      (false true true)]
[[true false true] (true true)]
[[false true true] (true true false true)]
[[true false]      (true false true false true true)]
[[true false true] (false true false true true true false)]

Answer 22

जावास्क्रिप्ट नियम 110 की व्याख्या , 131 बाइट्स (99 बाइट्स ?, 28 बाइट्स?)

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}
c=(l,n)=>!n?l:c(b(0+l+0),n-1)

जैसा कि आप देख सकते हैं, कोड 3 कार्यों को परिभाषित करता है a, bऔर c। शायद बाइट्स को 1 फ़ंक्शन में जोड़कर सहेजना संभव है (मैं नहीं देखता कि कैसे), लेकिन यह अच्छा है कि वहाँ अलग है क्योंकि उनमें से प्रत्येक पहले से ही कुछ अर्थों में इस चुनौती को पूरा करता है।

फंक्शन aइनपुट के रूप में 3 नंबर लेता है और उनमें से कुछ अजीब बहुपदों की गणना करता है। जब ये 3 नंबर होते हैं 0या 1इन्हें नियम 110 कोशिकाओं के रूप में देखा जा सकता है। aतब के उत्पादन की समता को अगली पीढ़ी में मध्य सेल के मूल्य के रूप में देखा जा सकता है। तो कुछ अर्थों में, यह सरल कार्य पहले से ही एक नियम 110 'दुभाषिया' (28 बाइट्स) है।

a=(p,q,r)=>(q+r+q*r+p*q*r)%2

फिर हम एक नया फंक्शन बना सकते हैं , जो स्ट्रिंगर्स और जीरो के हर चरित्र पर bमूल्यांकन करता है a। यह bहै, तो एक बेहतर तरीके से a, एक नियम 110 दुभाषिया। एक बचत कोष्ठक (99 बाइट्स) के मूल्यांकन के बाद मॉड 2 लेना:

a=(p,q,r)=>q+r+q*r+p*q*r
b=l=>{r="";for(i=0;i<l.length-2;i++)r+=a(l[i],+l[i+1],+l[i+2])%2;return r}

वास्तव में नियम 110 के साथ एक फ़ंक्शन की गणना करने के लिए, उपयोगकर्ता को प्रारंभिक स्थिति और पीढ़ियों की संख्या निर्दिष्ट करनी होगी, जिसके बाद आउटपुट 'दिखाई देगा'। हम एक तीसरा फ़ंक्शन बना सकते हैं जो cलोगों और शून्य का एक स्ट्रिंग लेता है, और एक सकारात्मक पूर्णांक n, जो तब bस्ट्रिंग, nसमय पर मूल्यांकन करता है । इस तरह हम वास्तव में नियम 110 को एक प्रोग्रामिंग भाषा के रूप में देख सकते हैं, जहां एक कार्यक्रम एक गहन राज्य और एक संख्या है n, और उत्पादन nपीढ़ियों के बाद की स्थिति है । फ़ंक्शन cअब उस प्रोग्रामिंग भाषा के लिए एक वास्तविक दुभाषिया है इसलिए इस चुनौती के लिए अंतिम कोड वही है जो मैंने ऊपर प्रस्तुत किया है।

Comments

क्या यह उचित पृष्ठभूमि के साथ 110 की गणना करता है? मेरा पहले का उत्तर हटा दिया गया था क्योंकि इसमें पृष्ठभूमि नहीं थी।

— गेहूं जादूगर

@WheatWizard बैकग्राउंड इनपुट का हिस्सा है, आपके उत्तर को उसके लिए डिलीट नहीं करना चाहिए

— जेन्स

पृष्ठभूमि अनंत होनी चाहिए, क्या आप अनंत इनपुट ले सकते हैं?

— गेहूं जादूगर

@ इसे बदलने के लिए अनंत होना चाहिए, इसे मनमाने ढंग से बड़ा बनाने में सक्षम होना चाहिए, और यह हो सकता है

— जेन्स रेंडर्स

नियम 110 यदि आप पहले से पीढ़ी तय करते हैं, तो ट्यूरिंग पूरा नहीं होता है, और आपको मेरे द्वारा बनाए गए निर्माण में अनंत इनपुट की आवश्यकता है। यहां तक ​​कि अगर किसी ने एक प्रारंभिक प्रारंभिक स्थिति के साथ एक निर्माण पाया, तो आप प्रोग्राम चलाने से पहले स्मृति या समय की आवश्यकता को नहीं जान सकते, क्योंकि तब आप हॉल्टिंग समस्या को हल कर सकते थे।

— अर्जन जोहान्सन

Answer 23

जेएस -> न्यूलाइन 854 बाइट्स

(function(d){var b=0;var n=!0;var c=[];var h=[];var e=0;var l=[];var m=0;var f=2;var a=0;var g=!1;var k=function(a){if(a===1)return!1;if(a%2===0&&a!==2)return!1;if(a%3===0&&a!==3)return!1;if(a%5===0&&a!==5)return!1;if(a%7===0&&a!==7)return!1;for(var b=7;b<d.round(d.sqrt(a))+1;b++)if(a%b===0)return!1;return f=a,!0;};var j=0;var i=0;var o=function(q){var o=d.__split(q,'\n');d.println(o);for(var n=0;n<o.length;n++)if(n>=f^2&&n<=f+1^2&&k(n)){f=n;for(var p=0;p<o[n].length;p++){if(o[n]==='+'&&(a+=c[b],b++),o[n]==='-')if(g===!0&&a<=0)break;else a-=c[b],b++;if(o[n]==='*'&&(a*=c[b],b++),o[n]==='/'&&(a/=c[b],b++),o[n]==='s'&&(a=d.sqrt(a)),o[n]==='%'&&(a%=c[b],b++),o[n]==='a'&&l.push(a),o[n]==='g'&&(a=c[b],b++),o[n]==='q'&&c.push(a),o[n]==='i'&&a++,o[n]==='d')if(g===!0&&a<=0)break;else a--;o[n]==='r'&&(g=!0),o[n]==='w'&&(g=!1),o[n]==='['&&(j=n),o[n]===']'&&a>0&&(n=j,h[e]--),o[n]==='{'&&(i=n),o[n]==='}'&&h[e]>0&&(n=i,h[e]--),m=a,o[n]==='k'&&e++;}}};});

सुपर गोल्फ गूगल के लिए धन्यवाद।

Comments

मुझे लगता है कि आपने इस जवाब को गलत चुनौती के रूप में पोस्ट किया है। क्या आप इसे इस चुनौती के लिए पोस्ट करने का मतलब ?

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

बहरहाल, ऐसे जवाब जो जीत की स्थिति के लिए अनुकूलन करने का गंभीर प्रयास नहीं करते हैं, वे नियमों के विरुद्ध हैं । इसे हटाने के लिए एक अच्छा पर्याप्त कारण है जब तक आप इसे नियमों के अनुरूप नहीं बना सकते।

आप सभी varकथनों को जोड़ सकते हैं :var b=0,n=!0,c=[],h=[],e=0,l=[],m=0,f=2,a=0,g=!1;

— फलों को तोड़ना

Pls सभी varty निकालें

— केवल

Answer 24

क्लोजर, 87 बाइट्स (नियम 110)

समानता कोड का श्रेय जेन्स रेंडर्स को जाता है! मैं वास्तव में इस बात को व्यक्त करने के लिए संघर्ष कर रहा था और मैं [p q r]बाइनरी से पूर्णांक में परिवर्तित होने और लुकअप टेबल का उपयोग करने जा रहा था ।

#(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%)

यहां partitionऔर क्लोजर के विनाशकारी तर्क आवेदन को काफी सरल बनाता है। यह फ़ंक्शन राज्यों के अनंत अनुक्रम को लौटाता है, इसलिए कॉल करने वाले की takeउतनी ही ज़िम्मेदारी होती है जितनी उन्हें ज़रूरत होती है या केवल nthएक विशिष्ट स्थिति पर छोड़ देने के लिए। अगर शून्य के साथ पैडिंग केवल एक के बजाय दो तत्व थे तो सीमा मुद्दों से बचते हुए, टेप लगातार बढ़ता जाएगा। अब यह मूल चौड़ाई के बराबर है।

उदाहरण:

(def f #(iterate(fn[S](for[[p q r](partition 3 1(concat[0]S[0]))](mod(+ q(* q(+ 1 p)r)r)2)))%))

(pprint (take 5 (f '(0 0 0 0 0 1 1 1 0 0 1 0 0))))
((0 0 0 0 0 1 1 1 0 0 1 0 0)
 (0 0 0 0 1 1 0 1 0 1 1 0 0)
 (0 0 0 1 1 1 1 1 1 1 1 0 0)
 (0 0 1 1 0 0 0 0 0 0 1 0 0)
 (0 1 1 1 0 0 0 0 0 1 1 0 0))

Comments

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

मैं देख रहा हूँ, कि इसके अनुकरण तब मुश्किल हो जाता है। क्लोजर cycleअनंत पैडिंग पैटर्न का निर्माण करने में सक्षम होगा, लेकिन पहला कदम निष्पादित करने पर अनंत समय लगेगा: /

— निकोइरह

इसके बारे में सोचने के लिए, उन पैडिंग पैटर्न को अतिरिक्त तर्कों के रूप में लेना और 1 ब्लॉक बाएं और दाएं द्वारा नकली टेप का विस्तार करना बहुत मुश्किल नहीं होगा। यहां जानकारी की गति 1 ब्लॉक / पुनरावृत्ति है, इसलिए हमें केंद्रीय ब्लॉक के चारों ओर "प्रकाश शंकु" को अनुकरण करने की आवश्यकता है जिसमें असममित संरचना है। (

— CMIIW

Answer 25

APL (Dyalog) → फ्रैक्ट्रन संस्करण, 15 बाइट्स

(⊃0~⍨××0=1|×)⍣≡

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

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

TIO लिंक 2 पुनरावृत्तियों के लिए फ़ंक्शन चलाता है (ताकि आप आउटपुट को देख सकें क्योंकि प्रोग्राम पहले समाप्त नहीं होता है), और पूरा होने तक दूसरा इनपुट चलाता है, जिसके बाद यह आउटपुट देता है।

(⊃0~⍨××0=1|×)⍣≡ बाएं तर्क के रूप में तर्कसंगतों की सूची लेता है, जिसे and के रूप में संदर्भित किया जाता है, और सही तर्क के रूप में इनपुट को ational के रूप में संदर्भित किया जाता है

(⊃0~⍨××0=1|×) फंक्शन ट्रेन

• 1|×( ×और decimal के उत्पाद के दशमलव बिंदु (modulo 1) के बाद भाग प्राप्त करें

• 0= क्या यह 0 के बराबर है?

• ×× इस परिणाम को ⊢ × ⊣ से गुणा करें, जहाँ भी तर्कसंगत × ger पूर्णांक नहीं है, इसे 0 से बदल दिया जाता है

• 0~⍨ सभी 0s निकालें

• ⊃ पहला तत्व प्राप्त करें

⍣लूप जब तक ≡इनपुट नहीं बदलता है, ध्यान दें कि परिणाम (⊃0~⍨××0=1|×)को इनपुट के रूप में पुन: उपयोग किया जाता है, इसलिए यदि यह बदलना बंद हो जाता है (अंत में 1 के परिणामस्वरूप) कार्यक्रम बंद हो जाता है

Answer 26

जावास्क्रिप्ट: लैम्ब्डा कैलकुलस ( 123 114)

डबल्स में डेब्रीजन इंडीमीटर्स का उपयोग करके प्रतिनिधित्व किया।

V=function b(c,d){if(!isNaN(c)){for(;--c;)d=d[1];return d[0]}return 0==c[0]?e=>b(c[1],[e,d]):b(c[0],d)(b(c[1],d))}

एस कॉम्बिनेटर है [0, [0, [0, [[3, 1], [2, 1]]]]]

के है [0, [0, 2]]

मैं हूं [0, 1]

संपादित करें: 9 बाइट्स को बदलकर शेव "number"==typeof cकिया गया!isNaN(c)

Answer 27

एपीएल (Dyalog यूनिकोड) , 15 बाइट्स ^SBCS

पूर्ण कार्यक्रम जो एक सामान्यीकृत एक आयामी सेलुलर ऑटोमेटोन निष्पादक को लागू करता है। इसमें नियम 110 शामिल है जो ट्यूरिंग पूर्ण है। प्रारंभिक अवस्था, पुनरावृत्तियों की संख्या (या ≡स्थिर होने तक जारी रहने या स्थिर होने तक {⍵≡⎕←⍺}सभी मध्यवर्ती मूल्यों को प्रदर्शित करने के लिए), और नियम-सेट के लिए स्टड को संकेत देता है ।

⎕∊⍨∘(⊢∘⊂⌺3)⍣⎕⊢⎕

इसे ऑनलाइन आज़माएं! (नियम ११० के ४ पुनरावृत्तियों)

⎕ प्रारंभिक अवस्था के लिए संकेत और

⊢ उपज जो (राज्य को पुनरावृत्तियों की संख्या से अलग करती है)

⍣⎕ पुनरावृत्तियों की संख्या के लिए संकेत और निम्न फ़ंक्शन लागू करें जो कई बार:

 (… ) निम्नलिखित tacit फ़ंक्शन लागू करें:

  ⌺3 सभी लंबाई -3 पड़ोस प्राप्त करें (इस बारे में जानकारी के साथ कि क्या वे किनारे पर हैं) और प्रत्येक जोड़े के लिए निम्नलिखित कार्य समारोह लागू करें:

   ⊂ पड़ोस को घेरें

   ∘ तथा

   ⊢ उपज कि (किनारे पर होने के बारे में जानकारी को त्यागना)

 ∘ फिर

 ∊⍨ जाँच करें कि क्या वे सदस्य हैं

 ⎕ पड़ोस की सूची के लिए संकेत अगले यात्रा में होने के लिए अग्रणी