कंप्यूटर एक निर्देश सेट कंप्यूटर डिजाइन!

सूचना: मैं किसी भी उत्तर को देने के लिए तैयार हूं जो मुझे दिलचस्प लगता है।

आपकी चुनौती ट्यूरिंग-पूरा एक निर्देश सेट कंप्यूटर (OISC) डिजाइन करना है:

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

यहाँ एकल कमांड के कुछ उदाहरण दिए गए हैं जो ट्यूरिंग-पूर्ण OISC बनाते हैं।

नियम:

आपको इसकी व्याख्या या प्रमाण देना होगा

आपको अपनी भाषा के लिए एक दुभाषिया प्रदान करना होगा। यह दुभाषिया केवल मेमोरी / समय तक सीमित होना चाहिए (उदाहरण के लिए उपयोगकर्ता द्वारा लगाए गए प्रतिबंध नहीं होने चाहिए)। यदि आप अपनी भाषा के लिए दुभाषिया (आलस्य के अलावा और किसी भी कारण से) प्रदान नहीं करते हैं, तो आपको यह साबित करना होगा कि यह एक के लिए संभव है। एक दुभाषिया संभव होना चाहिए ।

आपको इसकी ट्यूरिंग-पूर्णता साबित करनी होगी

आपको एक औपचारिक प्रमाण शामिल करना होगा कि आपकी भाषा ट्यूरिंग-पूर्ण है। ऐसा करने का एक सरल तरीका यह साबित करना है कि यह किसी अन्य ट्यूरिंग-पूर्ण भाषा के समान व्यवहार की व्याख्या कर सकता है या कर सकता है। व्याख्या करने के लिए सबसे बुनियादी भाषा ब्रेनफ ** के होगी ।

उदाहरण के लिए, एक सामान्य भाषा जिसमें ब्रेनफ ** k (और उपयोगकर्ता द्वारा लगाए गए मेमोरी प्रतिबंधों की समान कमी) के रूप में एक ही कमांड है, ट्यूरिंग-पूर्ण है क्योंकि कुछ भी जो ब्रेनफ ** k में लागू किया जा सकता है, उसे भाषा में लागू किया जा सकता है ।

यहां बहुत ही सरल-से-लागू ट्यूरिंग-पूर्ण भाषाओं की एक सूची है।

अतिरिक्त OISC आवश्यकताओं

इस OISC में केवल एक निर्देश होना चाहिए - इसमें एक से कई निर्देश नहीं हो सकते हैं, जिससे यह Turing-complete हो सके।
आपका ओआईएससी आपको किसी भी वाक्यविन्यास का उपयोग कर सकता है। आपको अपने उत्तर में परिभाषित करना चाहिए कि निर्देश क्या है, डेटा क्या है, और क्या नहीं है (जैसे व्हाट्सएप)। रचनात्मक बनो!
तर्क केवल पूर्णांक होने की आवश्यकता नहीं है। उदाहरण के लिए, /// ट्यूरिंग-पूर्ण OISC का एक सुंदर उदाहरण है।
इनपुट और आउटपुट कैसे और दिए गए हैं और दिए गए हैं। अधिकांश OISCs विशिष्ट मेमोरी स्थानों के माध्यम से I / O को लागू करते हैं, लेकिन ऐसा करने के अन्य तरीके हो सकते हैं, और आपको एक खोजने के लिए प्रोत्साहित किया जाता है।
एक वैध उत्तर को आपके OISC में कुछ उदाहरण कोड प्रदान करना चाहिए, या तो इसे पोस्ट में शामिल करके या भाषा में हल की गई सरल चुनौती से जोड़कर।

मतदान

मतदाता, कृपया बोरिंग सबमिशन को न बढ़ाएं। उदाहरण:

पेंगुइन - असमानताएं
मौजूदा ओआईएससी (उत्तरदाताओं का एक कार्यान्वयन, कृपया अपना खुद का बनाएं!)
एक "OISC" जिसमें पहला तर्क कॉल करने के लिए एक कमांड निर्दिष्ट करता है ( उदाहरण )

हालांकि, आपको दिलचस्प, रचनात्मक प्रस्तुतियाँ, जैसे:

एक गणितीय समीकरण के आधार पर OISC
तंत्रिका नेटवर्क पर आधारित एक ट्यूरिंग-पूर्ण ZISC
एक OISC जिसमें आउटपुट I / O कुछ निश्चित मेमोरी स्थानों की तुलना में अन्य तरीकों से होता है

जीतना

साथ के रूप में लोकप्रियता-प्रतियोगिता , सबसे ज्यादा वोटों के साथ जवाब जीतता है! सौभाग्य!

popularity-contest language-design

— एमडी एक्सएफ
स्रोत

एक "निर्देश" क्या है? और हम उन्हें कैसे गिनते हैं?

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

@NoOneIsHere मैं चाहता हूँ कि मैं सिर्फ xD को वोट करने के लिए पर्याप्त जानता था

— ब्रायन एच।

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

— NoOneIsHere

@MDXF मुझे नहीं लगता कि आपको मिलता है ///: इसमें एक प्रतिस्थापन कमांड है, और इसमें प्रिंट कमांड हैं, जो कि प्रतिस्थापन कमांड का सिर्फ एक साइड इफेक्ट नहीं है

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

@NoOneIsHere क्योंकि लोकप्रियता-प्रतियोगिता । हां, यह मान्य है, लेकिन इसमें खराब स्कोर (वोट टैली) है, इसलिए यह जीत नहीं पाएगा।

— 14:20 बजे यूजर 202729

जवाबों:

XOISC

यह ओआईएससी फोकर के एक्स-कॉम्बिनेटर पर आधारित है जिसे निम्नानुसार परिभाषित किया गया है:

एक्स = λ च । च (λ जी ज एक्स । जी एक्स (ज एक्स)) (λ ए ख सी । ए)

$X = \lambda f\ . f\ (\lambda g\ h\ x\ . g\ x\ (h\ x))\ (\lambda a\ b\ c\ . a)$

अगर हम इस तथ्य को स्वीकार करते हैं कि SKI- पथरी ट्यूरिंग को पूरा कर रही है तो उपरोक्त -combinator ट्यूरिंग भी पूरा हो गया है। ऐसा इसलिए है क्योंकि , और को संदर्भ में लिखा जा सकता है , जैसे: $X$ $S$ $K$ $I$ $X$

\begin{aligned} एस & = एक्स (एक्स एक्स) \\ कश्मीर & = एक्स एक्स \\ मैं = एस कश्मीर कश्मीर & = एक्स (एक्स एक्स) (एक्स एक्स) (एक्स एक्स) \end{aligned}

$\begin{align} S &= X\ (X\ X) \\ K &= X\ X \\ I = S\ K\ K &= X\ (X\ X)\ (X\ X)\ (X\ X) \end{align}$

XOISC कैसे काम करता है

आंतरिक रूप से XOISC में एक (शुरू में खाली) स्टैक होता है, वहां से निर्देश ले रहा है $n$ रूप में तर्क के रूप में निम्न कार्य करता है:

स्टैक से पॉप एलिमेंट्स (फ़ंक्शंस ), पुश करें $n$ $f_1 \dots f_N$ $f_1\ (f_2\ (\dots (f_N\ X) \dots ))$

एक बार और निर्देश न मिलने पर XOISC सभी कमांड-लाइन तर्कों (यदि कोई हो) को ढेर कर देगा, उदाहरण के लिए:

[\underset{stack before}{\underset{⏟}{s_{1}, \dots, s_{M}}}, \underset{arguments}{\underset{⏟}{a_{1}, \dots, a_{N}}}]

$[ \underbrace{s_1, \dots,\ s_M}_{\text{stack before}} ,\ \underbrace{a_1, \dots,\ a_N}_{\text{arguments}} ]$

अंतिम गणना हो जाएगा $(\dots ((\dots (s_1\ s_2) \dots)\ s_M)\ a_1) \dots) a_N$ ।

चूंकि XOISC में एक निर्देश केवल एक तर्क (मेमोरी ऑफ़सेट) लेता है, यहाँ तक कि उस निर्देश के लिए एक नाम का उपयोग करने का कोई कारण नहीं है। तो एक मान्य स्रोत फ़ाइल पूरी तरह से नए या व्हाट्सएप द्वारा अलग किए गए पूर्णांक का गठन करेगी, उदाहरण के लिए:

0 0 2 0 1 0 1

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

उदाहरण

आइए उपरोक्त उदाहरण लें (दाईं ओर बढ़ता हुआ ढेर):

\begin{aligned} 0 & पॉप 0 और लागू करें (यानी। पुश सिंगल एक्स) : & [एक्स] \\ 0 & फिर से बस धक्का एक्स : & [एक्स, एक्स] \\ 2 & पॉप 2 (ए, ख) और धक्का ए (ख एक्स) : & [एक्स (एक्स एक्स)] \\ 0 & बस धक्का एक्स : & [एक्स (एक्स एक्स), एक्स] \\ 1 & पॉप 1 (ए) और धक्का ए एक्स : & [एक्स (एक्स एक्स), एक्स एक्स] \\ 0 & बस धक्का एक्स : & [एक्स (एक्स एक्स), एक्स एक्स, एक्स] \\ 1 & पॉप 1 (ए) और धक्का ए एक्स : & [एक्स (एक्स एक्स), एक्स एक्स, एक्स एक्स] \end{aligned}

$\begin{align} & \texttt{0} & \text{pop 0 and apply (ie. push single } X \text{)}: & \quad [X] \\ & \texttt{0} & \text{again simply push } X: & \quad [X,\ X] \\ & \texttt{2} & \text{pop 2 (} a,b \text{) and push } a\ (b\ X): & \quad [X\ (X\ X)] \\ & \texttt{0} & \text{simply push } X: & \quad [X\ (X\ X),\ X] \\ & \texttt{1} & \text{pop 1 (} a \text{) and push } a\ X: & \quad [X\ (X\ X),\ X\ X] \\ & \texttt{0} & \text{simply push } X: & \quad [X\ (X\ X),\ X\ X,\ X] \\ & \texttt{1} & \text{pop 1 (} a \text{) and push } a\ X: & \quad [X\ (X\ X),\ X\ X,\ X\ X] \end{align}$

अंत में स्टैक का मूल्यांकन करें: या कम कोष्ठक जिसे हम अच्छे पुराने पहचान के रूप में पहचानते हैं समारोह। $((X\ (X\ X))\ (X\ X))\ (X\ X)$ $X\ (X\ X)\ (X\ X)\ (X\ X)$ $S\ K\ K$

ट्यूरिंग पूर्णता

प्रमाण विचार

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

$X$

$((X\ (X\ X))\ (X\ X))\ (X\ X)$

$X$ 0
अगले हम कोष्ठकों के एक नए स्तर पर हैं, इसलिए हमें फिर से केवल एक की आवश्यकता है 0
अब दो कोष्ठक बंद हो गए हैं, इसलिए हमें 2 तत्वों को पॉप करने की आवश्यकता है: 2
फिर से हम नए स्तर के कोष्ठकों में हैं, इसलिए हमें इसकी आवश्यकता है 0
दो कोष्ठक, करीब फिर से एक 2
और फिर वही

तो हम एक अलग (अभी तक शब्दार्थ समतुल्य) XOISC- कार्यक्रम के साथ समाप्त होते हैं:

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

यदि हम इस रणनीति के साथ बने रहें तो हम किसी भी अभिव्यक्ति को आसानी से बदल सकते हैं $X$ एक XOISC प्रोग्राम के लिए कॉम्बिनेटर जो केवल स्टैक पर एक फ़ंक्शन छोड़ता है।

औपचारिक प्रमाण

यह देखते हुए कि SKI-पथरी पूर्ण हो रही है, हमें दो चीजें दिखाने की जरूरत है:

$X$ -कम्बिनेटर SKI-पथरी के लिए एक आधार है
XOISC किसी भी अभिव्यक्ति का प्रतिनिधित्व करने में सक्षम है $X$ Combinator

पहला भाग - परिचय में तीन समानताएं साबित करना - बहुत थकाऊ और अंतरिक्ष की खपत है, यह भी बहुत दिलचस्प नहीं है। इसलिए इस पोस्ट में डालने के बजाय, आप यहाँ पा सकते हैं ^* ।

दूसरे भाग को संरचनात्मक प्रेरण द्वारा सिद्ध किया जा सकता है , हालांकि थोड़ा मजबूत कथन साबित करना आसान है: अर्थात्, किसी भी अभिव्यक्ति के लिए $X$ -कैमिनेटर एक ऐसा प्रोग्राम है जो स्टैक पर एकल एक्सप्रेशन के रूप में उस एक्सप्रेशन को छोड़ देगा:

इस तरह के निर्माण के दो तरीके हैं $X$ अभिव्यक्ति, या तो यह है $X$ खुद या $f\ g$ कुछ भावों के लिए $f$ तथा $g$ :

पूर्व एक तुच्छ है जैसा 0कि छोड़ देगा $X$ एक अभिव्यक्ति के रूप में ढेर पर। अब हम मानते हैं कि दो कार्यक्रम हैं ( $\texttt{F}_1 \dots \texttt{F}_N$ तथा $\texttt{G}_1 … \texttt{G}_K$ ) जो छोड़ देगा $f$ तथा $g$ स्टैक पर एक एकल अभिव्यक्ति के रूप में और साबित होता है कि कथन के लिए है $f\ g$ भी:

कार्यक्रम $\texttt{F}_1 \dots \texttt{F}_N\ \texttt{G}_1 \dots \texttt{G}_{K-1}\ (\texttt{G}_K + 1)$ पहले उत्पन्न होगा $f$ स्टैक पर और फिर यह उत्पन्न करेगा $g$ लेकिन इसके बजाय के केवल popping भागों $g$ यह भी पॉप जाएगा $f$ और इसे लागू करें, जैसे कि यह एकल अभिव्यक्ति को छोड़ देता है $f\ g$ ढेर पर। ∎

दुभाषिया

इनपुट

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

एक उदाहरण के रूप में यहां एक कार्यक्रम है जो दो संख्याओं को गुणा करता है: इसे ऑनलाइन आज़माएं!

आप डी ब्रूजन सूचकांकों का उपयोग करके तर्कों के रूप में भी कार्यों की आपूर्ति कर सकते हैं , उदाहरण के लिए Sकॉम्बिनेटर \\\(3 1 (2 1))(या λλλ(3 1 (2 1)))। हालांकि यह भी स्वीकार करता है S, K, Iऔर निश्चित रूप से XCombinator।

उत्पादन

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

कोडांतरक

बेशक किसी भी निम्न-स्तरीय भाषा को एक कोडांतरक की आवश्यकता होती है जो इसे उच्च-स्तरीय भाषा में परिवर्तित करता है, आप बस किसी भी इनपुट का उपयोग कर सकते हैं (ऊपर देखें) और -aझंडे का उपयोग करके XOISC- प्रोग्राम में अनुवाद करें , इसे ऑनलाइन आज़माएं! ^**

^{* यदि लिंक नीचे है, तो इस पोस्ट में HTML टिप्पणी के रूप में एक प्रति है।}

^{** यह एक कार्यक्रम में परिणाम देता है जो कि मौलिकता के लिए परीक्षण करता है, इसे ऑनलाइन आज़माएं!}

— ბიმო
स्रोत

क्या कोई कारण है जिसे आपने इओटा कॉम्बिनेटर के बजाय एक्स कॉम्बिनेटर उठाया है?

— फल

@EsolangingFruit: हाँ, कई अन्य विकल्प भी हैं, अंत में मैंने उस एक को चुना क्योंकि यह SK बनाने के लिए कम से कम अनुप्रयोगों का उपयोग करता है। ऐसा लग रहा था कि यह सबसे अच्छा प्रदर्शन करेगा (tbh मैंने खुद की तुलना नहीं की है)।

— ।

Btw। यदि आप रुचि रखते हैं तो लिंक्ड पेपर में कई कॉम्बीनेटरों की अच्छी तुलना है।

— ბიმო

खींचना

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

कार्यक्रम एक पंक्ति पहचानकर्ता (# या खाली स्थान के सहित मनमाना स्ट्रिंग नहीं), दो पूर्णांकों (युक्त लाइनों की एक अनुक्रम के होते हैं xऔर y) और दो और लाइन पहचानकर्ता ( aऔर b)।

कार्यक्रम रन इस प्रकार है:
लाइन के रूप में पहचान पर प्रारंभ हो startसूचक स्थान (0, 0) की ओर इशारा करते के साथ, द्वारा दिए गए राशि से पॉइंटर को चलाने xऔर yऔर वर्ग सूचक पर (जब तक कि वर्ग पहले से ही चिह्नित है अब है निशान, जिस स्थिति में निष्पादन समाप्त हो जाता है)। फिर, पंक्ति में कूदें aयदि सीधे आसन्न वर्गों में से कम से कम एक भी चिह्नित है, और bअन्यथा पंक्ति के लिए ।

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

ट्यूरिंग-संपूर्णता

ड्रा ट्यूरिंग-पूर्ण है क्योंकि भाषा में मिन्स्की मशीन के एक संशोधित संस्करण (जिसे वैकल्पिक कहा जाता है) को संकलित करना संभव है।

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

उदाहरण: यह मिन्स्की मशीन

1 inc A 2
2 inc A 3
3 dec A 3 4
4 halt

इस वैकल्पिक कार्यक्रम में बदल जाता है:

1 inc 2
2 nop 3
3 inc 4
4 nop 5
5 dec 6 8
6 nop 5
7 halt
8 halt

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

फिर, वैकल्पिक कार्यक्रम को सीधे ड्रा में अनुवादित किया जाता है:

कार्यक्रम इस ब्लॉक से शुरू होता है।

start 0 0 a a
a 3 0 b b
b -3 1 c c
c 3 0 d d
d -3 2 e e
e 3 0 f f
f 3 -3 i1_a i1_a

inc, decऔर nopलगभग एक दूसरे के समान अनुवाद किए जाते हैं। सभी मामलों में, पहले या दूसरे रजिस्टर को बदलने (जैसा कि ऊपर बताया गया है) में कोई अंतर नहीं है। यहाँ एक वृद्धि है, इसके बराबर inc 2:

i1_y 0 -2 i1_z i1_y
i1_z 3 -1 i1_a i1_a
i1_a -5 1 i1_b i1_b
i1_b 0 2 i1_c i1_c
i1_c 0 2 i1_d i1_e
i1_d 0 2 i1_d i1_f

i1_e 5 0 i2_z i2_y
i1_f 5 0 i2_z i2_y

i1_xभागों में संख्याओं को वर्तमान निर्देश के सूचकांक में बदलें , और i2_xभागों में निष्पादित होने वाले अगले निर्देश के सूचकांक में।

nopशिक्षा जैसे अनुवाद किया जा सकता:

i1_y 0 -2 i1_z i1_y
i1_z 3 -1 i1_a i1_a
i1_a -5 1 i1_b i1_b
i1_b 0 2 i1_c i1_c
i1_c 0 2 i1_d i1_e
i1_d 0 2 i1_d i1_f

i1_e 5 -2 i2_z i2_y
i1_f 5 -2 i2_z i2_y

यह एक गिरावट है:

i1_y 0 -2 i1_z i1_y
i1_z 3 -1 i1_a i1_a
i1_a -5 1 i1_b i1_b
i1_b 0 2 i1_c i1_c
i1_c 0 2 i1_d i1_e
i1_d 0 2 i1_d i1_f

i1_e 5 -2 i3_z i3_y
i1_f 5 -4 i2_z i2_y

i3_x यदि काउंटर पहले से ही 1 है, तो कॉल किए जाने वाले अनुदेश को संदर्भित करता है।

हॉल्ट:

i1_y 0 0 0 0
i1_z 0 0 0 0

उचित रूप से लेबल बदलें और बस सब कुछ एक साथ श्रृंखला। ऊपर से उदाहरण के लिए यह करना ऊपर से भंडार में ड्रा कार्यक्रम देता है।

दुभाषियों

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

draw.py : यह दुभाषिया कमांड लाइन के लिए होता है और प्रोग्राम सोर्स को एक तर्क के रूप में लेता है। हर कदम के बाद, यह उस कमांड को आउटपुट करता है जिसे निष्पादित किया गया था और निर्देश सूचक का स्थान; कार्यक्रम के रुकने के बाद, यह चिह्नित कोशिकाओं की संख्या को प्रिंट करता है।
draw_golly.py : यह संस्करण स्क्रिप्ट को शुरू करने के दौरान पॉपअप बॉक्स के माध्यम से स्रोत को ले कर ~~गलत उद्देश्य~~ आसान ग्राफिकल आउटपुट के लिए Golly का उपयोग करता है । गॉली पाइथन के साथ थोड़ी बारीक हो सकती है, इसलिए सुनिश्चित करें कि आपके पास पाइथन 2 स्थापित है (और 64-बिट पायथन या इसके विपरीत 32-बिट गोली को न मिलाएं)। आउटपुट गोली के बिलिन सेल ग्रिड के माध्यम से प्रदान किया जाता है।

निम्नलिखित छवि दूसरे दुभाषिया से आउटपुट के लिए एक उदाहरण है। रिपॉजिटरी में उदाहरण कार्यक्रम चलाने से यह (या समान) मिलता है:

— ivzem
स्रोत

गजब का! चुनौती करने के लिए एक बहुत ही अनूठा तरीका खोजने पर बधाई।

— एमडी XF

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

— Akangka

Golly के लिए +1 सर्वश्रेष्ठ सेलुलर ऑटोमेटा सिम्युलेटर एवर।

— HighlyRadioactive

-3

यहाँ जिरह है।

स्मृति

मेमोरी टेपों का एक मानचित्र है, जहां चाबियाँ तार हैं और मान मनमाने आकार के पूर्णांक हैं।

इसके अतिरिक्त, लेबल का एक सेट है, जहां कार्यक्रम में कूद सकते हैं।

एक स्टैक होता है, जिसमें ऑपरेंड होते हैं, जो स्ट्रिंग्स होते हैं।

एक ऑफ़ेस्ट है, जो नियंत्रण करता है कि मेमोरी के टेप में यह कहां पहुंच सकता है।

एक निर्देश

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

if mem[A] < mem[B]:
    jump to LABEL
if mem[A] != mem[B]:
    mem[A]--
else:
    mem[B]++

ध्यान दें कि यदि अतिरिक्त तर्क या अपर्याप्त तर्क हैं, तो कार्यक्रम की स्थिति दिखाते हुए, प्रोग्राम त्रुटि करेगा।

के मान तक पहुँच कर ऑफसेट को संशोधित किया जा सकता है .।

उदाहरण कोड

X-

i i X-
i i X-
i i X-
i i X-
i i X-
i i X-
i i X-

यह समय iको बढ़ाकर 7, चर सेट करता है 7।

X-

i i X-
i i X-
i i X-
LOOP-
    a a X-
    a a X-
    j i LOOP-

यह i+1स्थिरांक से गुणा करता है 2।

ट्यूरिंग कम्प्लीटनेस का सबूत

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

मेरा यह भी मानना है कि किसी भी BCT को -3 प्रोग्राम के रूप में लिखा जा सकता है।

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

जैसा कि मुझे अपनी सामग्री में सुधार करने के लिए प्यार है, कृपया, नीचे वोट के बारे में एक स्पष्टीकरण की सराहना की जाएगी

— कॉनर ओ'ब्रायन