ट्यूरिंग पूर्णता के लिए सबसे (विशिष्ट) वर्ण


107

सारांश:

किसी भी भाषा के लिए, ट्यूरिंग-कम्पलीट होने के लिए आपकी भाषा के लिए अद्वितीय वर्णों की सबसे छोटी राशि क्या है ?

चुनौती:

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


उदाहरण:

  • जावास्क्रिप्ट: +!()[]( http://www.jsfuck.com )

  • Brainfuck: +<>[](एक रैपिंग सेल आकार मानता है)

  • अजगर 2: ()+1cehrx(जैसे स्क्रिप्ट से बना exec(chr(1+1+1)+chr(1)))

स्कोरिंग:

यह चुनौती बाइट्स में नहीं बल्कि पात्रों में बनाई जाती है । उदाहरण के लिए, उदाहरण के लिए स्कोर 6, 5 और 9 हैं।


टिप्पणियाँ:

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

  • यद्यपि आप कर सकते हैं, कृपया उपयोग किए गए वर्णों को कम किए बिना उत्तर पोस्ट न करें। उदाहरण: 8 अक्षरों के साथ ब्रेनफैक (चूंकि हर दूसरा चरित्र डिफ़ॉल्ट रूप से एक टिप्पणी है।)

  • आपको कम से कम एक संक्षिप्त विवरण प्रदान करना होगा कि आपका सबसेट ट्यूरिंग-पूर्ण क्यों है।


90
Unary , 1 वर्ण। sighs
डेनिस

4
@ डेनिस यह नहीं है कि जेली या 05AB1E से अलग एक दिलचस्प संख्या सिद्धांत समस्या के लिए अंतर्निहित है। यह चुनौती अभी भी किसी भी भाषा में एक दिलचस्प और गैर-तुच्छ अनुकूलन समस्या की तरह प्रतीत होती है, जिसे टारपीट के रूप में तैयार नहीं किया गया था।
मार्टिन एंडर

7
@MartinEnder मुझे विशेष रूप से जावा या C. जैसी भाषाओं में उत्तर देखने में दिलचस्पी होगी
Julian Lachniet

9
कृपया सॉल्वैंट्स में समाधान पोस्ट न करें जहां समाधान भाषा में हर वैध चरित्र है। यह इंट्रोस्टिंग या चतुर नहीं है।
पावेल

20
@Pavel दिलचस्प या चालाक नहीं हो सकता है इसका मतलब यह है कि इसे उठना नहीं चाहिए, लेकिन निश्चित रूप से ऐसा नहीं है कि इसे पोस्ट नहीं किया जाना चाहिए।
डेनिस

जवाबों:


77

हास्केल, 4 वर्ण

()=;

साथ ()=हम एस, कश्मीर और मैं परिभाषाओं या तो द्वारा अलग किया जाना चाहिए परिभाषित करने में सक्षम हैं ;या एक NL।

हम (==)एस के रूप में परिभाषित करते हैं (दूसरी पंक्ति एक अधिक पठनीय संस्करण दिखाती है):

((=====)==(======))(=======)=(=====)(=======)((======)(=======))
( a     == b      ) c       = a      c       ( b       c       )

(===) पूछना:

(=====)===(======)=(=====)
 a     === b      = a

और (====)जैसा कि मैंने:

(====)(=====)=(=====)
(====) a     = a 

सौभाग्य से (==), (===), (====), आदि वैध समारोह / पैरामीटर नाम हैं।

जैसा कि @ ais523 बताते हैं, एसकेआई हास्केल जैसी दृढ़ता से टाइप की गई भाषा में पर्याप्त नहीं है, इसलिए हमें एक फ़िक्सपॉइंट कॉम्बिनेटर जोड़ने की आवश्यकता है (=====):

(=====)(======)=(======)((=====)(======))
(=====) f      = f      ((=====) f      )

17
यह निर्माण सीधे काम नहीं करता है; एसकेआई हास्केल जैसी दृढ़ता से टाइप की गई भाषा में पूरा नहीं हो रहा है। हालांकि, मेरा मानना है कि आप को परिभाषित करने के उसी तकनीक का उपयोग कर सकते हैं fix, और स्की + fix है ट्यूरिंग पूरा, एक दृढ़ता से टाइप किया भाषा में भी।

ओह, तो आप प्रत्येक कार्यक्रम की शुरुआत में उन परिभाषाओं को उपसर्ग करते हैं?
PyRulez

@PyRulez: हाँ। हमारी चूक के अनुसार, मेरा मानना ​​है कि दिए गए वर्ण सेट के साथ कार्यों का निर्माण करने में सक्षम होना पर्याप्त है - एक पूर्ण कार्यक्रम की आवश्यकता नहीं है।
निमि

1
आपको संभवतः (==)इसे बदल देना चाहिए ताकि यह डिफ़ॉल्ट समानता ऑपरेटर के साथ संघर्ष न करे
गर्वित हैकेलर

@proudhaskeller: हां, अगर आप वास्तव में प्रोग्राम करना चाहते हैं तो इसका नाम बदलना बेहतर होगा (==), लेकिन उपरोक्त कोड ट्यूरिंग पूर्णता का एक प्रमाण मात्र है।
नौ

61

जावास्क्रिप्ट (ईएस 6), 5 वर्ण

इसके साथ मदद करने के लिए @ETHproductions और @ATaco को धन्यवाद; यह एक समूह परियोजना थी, और हालांकि मूल विचार मेरा था, कई विवरण उनके हैं। चैट चर्चा देखें कि यह जावास्क्रिप्ट सबसेट यहाँ कहाँ विकसित किया गया था ।

[]+=`

यह काफी अच्छी तरह से स्थापित है कि किसी भी जावास्क्रिप्ट प्रोग्राम को अक्षरों ( []()+!) के साथ लिखा जा सकता है , लेकिन 5 अक्षर पर्याप्त नहीं हैं । हालाँकि, यह मनमाना जावास्क्रिप्ट लिखने के बारे में चुनौती नहीं है। यह ट्यूरिंग-पूर्ण भाषा लिखने के बारे में एक चुनौती है, और इस तथ्य का उपयोग करते हुए कि ट्यूरिंग-पूर्ण भाषाओं को DOM, या यहां तक ​​कि इंटरैक्टिव I / O तक पहुंच की आवश्यकता नहीं है, यह पता चला है कि हम सभी कार्यक्षमता के साथ एक प्रोग्राम लिख सकते हैं आवश्यक , यहां तक ​​कि एक evalया एक बराबर चलाने के लिए किसी भी क्षमता के बिना ।

मूल बूटस्ट्रैपिंग

जावास्क्रिप्ट प्रकार के साथ बहुत लचीला है। उदाहरण के लिए, []एक खाली सरणी है, लेकिन +[]0 है, और []+[]अशक्त स्ट्रिंग है। विशेष रूप से, यह तथ्य कि हम इस चरित्र सेट के साथ 0 का उत्पादन कर सकते हैं, यह समूहीकरण के लिए कोष्ठक के प्रभाव का अनुकरण करना संभव बनाता है; (a)के रूप में लिखा जा सकता है [a][+[]]। हम इस प्रकार की चाल का उपयोग करके केवल विभिन्न वर्णों का उपयोग कर सकते हैं +[]:

  • [][+[]]है undefined(एक खाली सरणी का पहला तत्व होने के नाते); इसलिए
  • []+[][+[]]है "undefined"(कड़ेपन की undefined); इसलिए
  • [[]+[][+[]]]है ["undefined"](एक सरणी में लपेटकर कि); इसलिए
  • [[]+[][+[]]][+[]]है "undefined"(इसका पहला तत्व); इसलिए
  • [[]+[][+[]]][+[]][+[]]है "u"(इसका पहला अक्षर)।

uबनाने में सबसे आसान पात्रों में से एक है, लेकिन इसी तरह की तकनीकें हमें अन्य पात्रों की एक श्रृंखला बनाने देती हैं। एक ही कड़ी के रूप में पहले हमारे साथ सुलभ पात्रों में से निम्नलिखित सूची प्रदान करती है +[](इस के लिए के रूप में ही सूची है +[](), को छोड़कर ,क्योंकि यह केवल निर्माण समूहीकरण / पूर्वता के अलावा किसी अन्य उद्देश्य के लिए कोष्ठक का उपयोग करता है है):

0123456789acdefinotuvyIN (){}.

हम वर्णों के इस सेट से बहुत उपयोगी शब्दों को नहीं निकाल सकते हैं (याद रखें कि यह उन वर्णों का समूह है जिन्हें हम स्ट्रिंग्स के रूप में उत्पन्न कर सकते हैं ; हम उन्हें किसी प्रकार के बिना निष्पादित नहीं करते हैं eval)। जैसे, हमें एक और चरित्र की आवश्यकता है। हम इसका उपयोग करेंगे =, क्योंकि यह बाद में उपयोगी होगा, लेकिन कुछ समय के लिए, हम इसका उपयोग तुलना ऑपरेटर का उपयोग करने के लिए करेंगे ==। यह हमें उत्पादन करने की अनुमति देता है falseऔर true, जिसे कड़े और अनुक्रमित किया जा सकता है, और तुरंत हमें lrsउन वर्णों में जोड़ सकते हैं जिन्हें हम तार में शामिल कर सकते हैं।

अब तक, सबसे महत्वपूर्ण शब्द जो हमें मंत्र देता है, जिसे हम पहले नहीं कर सकते थे, है constructor। अब, जावास्क्रिप्ट में एक संपत्ति एक्सेस सिंटैक्स है जो इस तरह दिखता है:

object.property

लेकिन आप इसे इस तरह भी लिख सकते हैं:

object["property"]

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

object["c"+"o"+"n"+"s"+"t"+"r"+"u"+"c"+"t"+"o"+"r"]

(ऊपर वर्णित पत्रों के साथ उत्पन्न; कोड जल्दी से बहुत लंबा हो जाता है !); यह उसके समतुल्य है object.constructor, जो हमें मनमानी वस्तुओं के निर्माणकर्ताओं तक पहुँचने देता है।

इसके साथ हम कई ट्रिक्स कर सकते हैं। सांसारिक से शानदार करने के लिए:

  • किसी वस्तु का निर्माता एक कार्य है। विशेष रूप से, इसका एक नाम है, और यह नाम फ़ंक्शन के मानकीकरण का हिस्सा है। उदाहरण के लिए, हम [[]+[]][+[]]["constructor"]एक स्ट्रिंग के लिए कंस्ट्रक्टर पर प्राप्त कर सकते हैं , जिसका नाम स्ट्रिंग है, और फिर इसे कैपिटल Sकैरेक्टर पर लाने के लिए इसे स्ट्रिंग करें । यह हमारे वर्णमाला को थोड़ा विस्तार देता है, और हमें बाद में कुछ नए पात्रों की आवश्यकता है।
  • सभी सरणियों में एक ही निर्माता है; []["constructor"] == []["constructor"]है true(के विपरीत [] == []है, जो गलत है)। यह मामूली लग सकता है, लेकिन यह बहुत महत्वपूर्ण है, क्योंकि यह हमें मूल्यों को स्थिर रखने की एक विधि देता है; हम कंस्ट्रक्टर पर एक यादृच्छिक संपत्ति सेट कर सकते हैं, और बाद में इसे वापस पढ़ सकते हैं। (यह एक कारण हम प्रयोग कर रहे में से एक है =अन्य तरीकों से उत्पन्न करने के लिए में से एक विशेष रूप से, के बजाय trueऔर falseहम मूल्यांकन कर सकते हैं।) उदाहरण के लिए, [[]["constructor"]["a"]=[]]पढ़ने के लिए, और बाद में []["constructor"]["a"]और हम वहाँ संग्रहीत एक ही सरणी वापस मिलता है।

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

  • यह हमें एक फ़ंक्शन के लिए कंस्ट्रक्टर पर जाने की अनुमति देता है (ऐसे बहुत सारे कार्य हैं जिन्हें हम अपने सीमित वर्णमाला के साथ एक्सेस कर सकते हैं []["find"], अर्थात Array.find, सबसे आसानी से सुलभ है, लेकिन अन्य हैं)। क्यों उपयोगी है? ठीक है, हम वास्तव में एक निर्माता के उद्देश्य के लिए इसका उपयोग कर सकते हैं, और कार्यों का निर्माण कर सकते हैं! दुर्भाग्य से, हमारे चरित्र सेट के साथ, हम फंक्शन कंस्ट्रक्टर को एक गणना स्ट्रिंग पास नहीं कर सकते हैं। हालाँकि, इसका उपयोग `हमें एक स्ट्रिंग शाब्दिक (जैसे []["find"]["constructor"]`function body goes here`) पास करने देता है; इसका मतलब यह है कि हम निष्पादित होने पर किसी भी व्यवहार के साथ फ़ंक्शन प्रकार के कस्टम मानों को परिभाषित कर सकते हैं, इसलिए जब तक हम उस व्यवहार को पूरी तरह से उपयोग कर व्यक्त कर सकते हैं []+=। उदाहरण के लिए, []["find"]["constructor"]`[]+[]`एक काफी उबाऊ कार्य है जो अशक्त स्ट्रिंग की गणना करता है, इसे छोड़ता है, और बाहर निकलता है; उसफ़ंक्शन उपयोगी नहीं है, लेकिन अधिक जटिल होंगे। ध्यान दें कि हालांकि फ़ंक्शंस पैरामीटर या रिटर्न मान नहीं ले सकते हैं, लेकिन वे व्यवहार में समस्याएं नहीं हैं क्योंकि हम एक फ़ंक्शन से दूसरे में संचार करने के लिए कंस्ट्रक्टर-प्रॉपर्टी स्टोरेज का उपयोग कर सकते हैं। एक और प्रतिबंध यह है कि हम `एक फ़ंक्शन के शरीर में उपयोग नहीं कर सकते हैं ।

    अब, हम कस्टम फ़ंक्शंस को परिभाषित कर सकते हैं, लेकिन इस बिंदु पर हमें जो पकड़ना है वह कठिनाई है जो हमें उन्हें कॉल करने में है। कार्यक्रम के शीर्ष स्तर पर, हम किसी फ़ंक्शन को कॉल कर सकते हैं ``, लेकिन केवल शीर्ष स्तर से फ़ंक्शन को कॉल करने में सक्षम होने से हमें किसी भी प्रकार का लूप करने की अनुमति नहीं है। बल्कि, हमें एक-दूसरे को कॉल करने में सक्षम होने के लिए कार्यों की आवश्यकता है।

    हम इसे एक निफ्टी ट्रिक के साथ पूरा करते हैं। याद रखें कि Sपहले हमने जो पूंजी बनाई थी? जो हमें मंत्रमुग्ध कर देता है "toString"। हम इसे कॉल नहीं करने जा रहे हैं; हम चीजों []को उनके साथ जोड़कर तार में परिवर्तित कर सकते हैं। बल्कि, हम इसे प्रतिस्थापित करने जा रहे हैं । हम कंस्ट्रक्टर स्टोरेज का उपयोग लगातार सरणियों को परिभाषित करने के लिए कर सकते हैं जो चारों ओर चिपकती हैं। फिर हम सरणियों के toStringतरीकों के लिए अपने बनाए गए कार्यों को असाइन कर सकते हैं , और वे असाइनमेंट भी चारों ओर चिपक जाएंगे। अब, हमें बस इतना करना है कि यह एक सरल +[]सरणी है, और अचानक, हमारा कस्टम-परिभाषित फ़ंक्शन चलेगा। इसका मतलब है कि हम पात्रों का उपयोग कर सकते हैं+=[]फ़ंक्शन को कॉल करने के लिए, और इसलिए हमारे फ़ंक्शन एक-दूसरे को कॉल कर सकते हैं - या स्वयं। यह हमें पुनरावृत्ति देता है, जो हमें लूप देता है, और अचानक हमारे पास ट्यूरिंग-पूर्णता के लिए आवश्यक सब कुछ है।

यहां ट्यूरिंग-पूर्णता प्रदान करने वाली सुविधाओं का एक समूह है, और वे कैसे कार्यान्वित किए जाते हैं:

  • अनबाउंडेड स्टोरेज : कंस्ट्रक्टर स्टोरेज में नेस्टेड एरेज़
  • नियंत्रण प्रवाह : का उपयोग कर लागू किया ifऔर पुनरावृत्ति:
    • if: एक बूलियन को एक संख्या में परिवर्तित करें, और 2-तत्व सरणी में अनुक्रमित करें; एक तत्व उस thenस्थिति के लिए फ़ंक्शन चलाता है जब स्ट्रिंग किया जाता है, तो दूसरा तत्व elseस्ट्रिंग के मामले में फ़ंक्शन को चलाता है
    • पुनरावर्तन : कंस्ट्रक्टर भंडारण के एक उपयुक्त तत्व को कड़ा करता है
  • कमांड अनुक्रमण : [a]+[b]+[c]मूल्यांकन करता है a, bऔर cबाएं से दाएं (कम से कम मेरे द्वारा देखे गए ब्राउज़र पर)

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


16
यदि यह नाम नहीं है, तो मुझे सुझाव है कि J5h * t।
कैलकुलेटर

1
एक अच्छा उदाहरण कार्यक्रम क्या होगा? प्राइम टेस्ट? नमस्ते दुनिया?
कैलकुलेटर

3
मेरी, यह इतना वाट है ... स्वादिष्ट उत्तर, एक अच्छी हॉरर फिल्म की तरह।
वामावर्तियों को बंद करना बंद कर दिया

4
मुझे लगा कि एंगुलर 1 का toString()निर्भरता इंजेक्शन के लिए उपयोग फ़ंक्शन का उपयोग करने का सबसे रचनात्मक तरीका है। अब मैंने अपना इरादा बदल दिया।
सनी पुण

1
यहाँ एक उदाहरण दिया गया है: pastebin.com/QGbjmB5Y
19

55

Unary , 1 वर्ण

0

चरित्र का चुनाव वास्तव में मायने नहीं रखता है; कार्यक्रम की लंबाई मस्तिष्क ट्रांसफ़ेक्ट कार्यक्रम को परिभाषित करती है जो इसे स्थानांतरित करता है। जबकि युक्ति 0वर्णों को अनिवार्य करती है, अधिकांश ट्रांसपाइलर्स इसकी जांच नहीं करते हैं।


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

5
मैं स्तब्ध हूँ। मुझे यह बताने के लिए 20 मिनट चाहिए कि क्या यह एक मजाक है।
पीटर ए। श्नाइडर

3
@ पीटरए.निएडर कुछ गुगली पाएंगे कि किसी ने वास्तव में सिद्धांत रूप में एक क्वीन को लागू किया था, हालांकि परिणामी स्ट्रिंग 0 की संभवतः सबसे बड़ी संख्या है जिसे मैंने कभी किसी व्यावहारिक संदर्भ में देखा है और कभी भी वास्तविक मशीन पर लागू नहीं किया जा सकता है।
डैरेन रिंगर

12
शून्य का वह तार वास्तव में सबसे छोटी संख्या है जिसे मैंने कभी भी किसी भी संदर्भ में देखा है।
मैथ्यू

1
LOL, ठीक है, अगर आप एक मूर्खतापूर्ण पहचान के रूप में अपने एकमात्र प्रतीक को परिभाषित करने की तरह मूर्खतापूर्ण कुछ करते हैं ...: p
डैरेन रिंगर

37

vim, 9 8 7 6 अक्षर

<C-v><esc>1@ad

हम निम्नानुसार एक मनमाना vimcript प्रोग्राम बना और निष्पादित कर सकते हैं:

  1. रजिस्टर में aa<C-v><C-v>1<esc>dd@1<esc>ddddएक प्राप्त करने के लिए अनुक्रम का उपयोग करें ।<C-a>1

  2. के साथ डालें मोड दर्ज करें a, फिर एक डालें a, जो बाद में एक मैक्रो में सम्मिलित मोड को फिर से दर्ज करने के लिए उपयोग किया जाएगा।

  3. वांछित वर्णमाला कार्यक्रम में प्रत्येक वर्ण के लिए,

    1. <C-v><C-v>1<esc>शाब्दिक अनुक्रम सम्मिलित करने के लिए उपयोग करें <C-v>1,

    2. उपयोग @1(जो है <C-a><cr>, जिसमें <cr>अंतिम पंक्ति पर होने के कारण फाइनल एक सेशन नहीं है) 1जब तक वांछित चरित्र के ASCII मान तक पहुंचने के लिए आवश्यक है,

    3. और फिर से डालने मोड के साथ दर्ज करें a

  4. के साथ 1रजिस्टर में लाइन (एक अनुगामी न्यूलाइन के साथ) को हटा दें <esc>dd

  5. परिणाम का उपयोग करके vim कीस्ट्रोक्स के रूप में निष्पादित करें @1, फिर <esc>ddपिछले चरण से अनुवर्ती न्यूलाइन द्वारा दर्ज की गई लाइन को हटाने के लिए।

  6. के साथ बाइट्स के परिणामस्वरूप मनमाना अनुक्रम चलाएं dd@1। यदि यह एक के साथ शुरू होता है :, तो इसे विम्सस्क्रिप्ट कोड के रूप में व्याख्या किया जाएगा, और इसे अनुगामी न्यूलाइन के कारण चलाया जाएगा dd

मुझे यकीन नहीं है कि यह एक न्यूनतम चरित्र सेट है, लेकिन ट्यूरिंग-पूर्ण साबित होना काफी आसान है।


2
क्या आप i<C-v>1<ESC>लिखने के लिए नहीं कर सकते हैं <C-a>और फिर ddआप @1किसी भी संख्या को बढ़ाने के लिए उपयोग कर सकते हैं और उपयोग करने के लिए नहीं होने के परिणामस्वरूप <C-a>?
गाय नीम हकीम

4
वाह, यह जवाब अविश्वसनीय है! +1!
डीजेएमकेम

@KritiiLithos कि पुनर्गठन के एक बिट के बाद काम खत्म होता है, धन्यवाद!
दरवाज़े

2
@ mbomb007 वास्तव में ... एक दिलचस्प कार्यान्वयन विवरण के कारण, <C-v>10\ N (न पूछें) के बजाय NUL सम्मिलित करता है। किसी भी मामले में, हाँ, यह ट्यूरिंग-पूर्णता के संबंध में कोई बात नहीं है।
दरवाज़े

1
क्या यह छोटा हो सकता है? golf.shinh.org/p.rb?Hello+broken+keyboard#Vim
mbomb007

33

पर्ल, 5 अक्षर

<>^es

अन्य स्क्रिप्टिंग भाषाओं के साथ, विचार evalमनमाने ढंग से तार करने के लिए है। हालाँकि, हमारे चरित्र सेट में उद्धरण या संगति संचालक शामिल नहीं हैं, इसलिए मनमाने तरीके से निर्माण करना अधिक जटिल है। ध्यान दें कि eval^"इससे निपटने के लिए बहुत सरल होगा, लेकिन एक और चरित्र है।

हमारा मुख्य उपकरण है s<^><CODE>ee, जो विकसित होता है CODE, फिर इसका उत्पादन होता है। अधिक eजोड़ा जा सकता है, अपेक्षित प्रभाव के साथ।

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

उन तारों को एक साथ जोड़कर, हम वर्णों के किसी भी संयोजन को प्राप्त कर सकते हैं ^B^V^S(*-/9;<>HJMOY[`\^begqstv, जब तक हम चारों ओर कुछ कचरा होना स्वीकार करते हैं (उनमें से पहले तीन नियंत्रण चार्ट हैं)।

उदाहरण के लिए, मान लें कि हम पाना चाहते हैं "v99"। प्राप्त करने का एक तरीका v99है "><<" ^ "e>>" ^ "see" ^ "^^^", लेकिन हम उन बाधाओं का प्रतिनिधित्व नहीं कर सकते हैं जिनके कारण बाधाएं हैं <>। इसके बजाय, हम उपयोग करते हैं:

<^<<^>><>>^<^^^^^<>>^<^^^^^^e>^<^^^^^^^>^<^^^^^e>^<^^^^e^>^<e^^es>^<^ee^^>^<^<^^^^^>>^<^<>^^^^>^<^^^^^^^e>^<^^^^^^^^>

उपर्युक्त पैदावार Y9;v99;, जो, जब eval-ed, एक परिणाम के रूप में एक सादा v99(अर्थात्, ASCII 99 के साथ चरित्र) पैदा करता है।

इस प्रकार हम ^B^V^S(*-/9;<>HJMOY[`\^begqstvअपनी मनमानी स्ट्रिंग उत्पन्न करने के लिए पूरे चारसेट का उपयोग कर सकते हैं , फिर इसे ऊपर के रूप में परिवर्तित कर सकते हैं और इसे s<><CODE>eeeeनिष्पादित करने के लिए इसे एक में चिपका सकते हैं। दुर्भाग्य से, यह चरवाहा अभी भी बहुत सीमित है, बिना किसी स्पष्ट तरीके के संघटन करने के लिए।

लेकिन सौभाग्य से, इसमें तारा शामिल है। यह हमें लिखने देता है *b, जो स्ट्रिंग का मूल्यांकन करता है "*main::b"। फिर, *b^<^B[MMH^V^SY>(^ बी, ^ वी और ^ एस शाब्दिक नियंत्रण चरित्र) हमें देता है (6, $&);, जो है, जब फिर से eval-एड, पर्ल के मैच चर का मान देता है, $&। यह हमें एक सीमित रूप का उपयोग करने देता है: हम बार-बार चीजों को $_उपयोग करने के लिए तैयार कर सकते हैं s<^><THINGS>e, और फिर s<\H*><*b^<^B[MMH^V^SY>>eeeeval $_( \Hकुछ भी लेकिन क्षैतिज व्हाट्सएप से मिलान करते हैं; हम डॉट के बजाय इसका उपयोग करते हैं, जो हमारे चार्ट में नहीं है)।

का उपयोग करके 9-/, हम आसानी से सभी अंक उत्पन्न कर सकते हैं। अंकों, vऔर संघनन का उपयोग करके , हम मनमाने ढंग से अक्षर उत्पन्न कर सकते हैं (vXXX ASCII कोड XXX के साथ चरित्र की पैदावार करता है)। और हम उन्हें संक्षिप्त कर सकते हैं, इसलिए हम मनमाने तार उत्पन्न कर सकते हैं। इसलिए ऐसा लग रहा है कि हम कुछ भी कर सकते हैं।

चलिए एक पूरा उदाहरण लिखते हैं। मान लीजिए हम एक ऐसा प्रोग्राम चाहते हैं जो अपने खुद के पीआईडी ​​प्रिंट करता है। हम प्राकृतिक कार्यक्रम से शुरू करते हैं:

say$$

हम इसे वि-नोटेशन में बदलते हैं:

s<><v115.v97.v121.v36.v36>ee

हम इसे केवल ^B^V^S(*-/9;<>HJMOY[`\^begqstv(व्हाट्सएप केवल पठनीयता के लिए उपयोग करते हैं और आउटपुट को प्रभावित नहीं करते हैं) को फिर से लिखते हैं :

s<^><
    s<^><9*9-9-9-9-9-9>e;
    s<^><v>;
    s<v\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><9*9-9-9-9-9-9>e;
    s<^><v>;
    s<v\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><99-99/-9-99/-9>e;
    s<^><v>;
    s<v\H\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><99-9/9-9/9>e;
    s<^><v>;
    s<v\H\H><*b^<^B[MMH^V^SY>>eee;
    s<^><999/9-9/-9-9/-9-9/-9-9/-9>e;
    s<^><v>;
    s<v\H\H\H><*b^<^B[MMH^V^SY>>eee;
    s<\H*><*b^<^B[MMH^V^SY>>eee;
>eee;

अंत में, हम केवल करने के लिए उपरोक्त कार्यक्रम कन्वर्ट <>^es: pastebin । अफसोस की बात है कि यह पर्ल के साथ दुर्घटनाग्रस्त हो गया Excessively long <> operator, लेकिन यह सिर्फ एक तकनीकी सीमा है और इसे ध्यान में नहीं रखा जाना चाहिए।

पे, वह काफी यात्रा थी। यह देखना दिलचस्प होगा कि कोई व्यक्ति 5 पात्रों के सेट के साथ आता है जो चीजों को सरल बनाता है।

संपादित करें: थोड़ा अलग दृष्टिकोण का उपयोग करके, हम लंबाई सीमा को मारने से बच सकते हैं <>। पूरी तरह से कार्यात्मक ब्रेनफैक दुभाषिया केवल का उपयोग कर <>^es: यह ऑनलाइन कोशिश करो! । स्वचालित पर्ल को <>^estranspiler: pastebin


1
मैं देख रहा हूँ .. आपके एन्कोडिंग को द्विघात आघात हो जाता है क्योंकि आपके वर्ण दो समूहों में विभाजित होते हैं, एक जो केवल आधार वर्णों की एक समान संख्या को xor'ing द्वारा निर्मित किया जा सकता है, और दूसरा जो केवल एक विषम संख्या द्वारा निर्मित किया जा सकता है, आपको मजबूर कर सकता है जब भी उनके बीच कोई और ग्लोब जोड़ें। कोई भी मौका जिससे आप कार्यक्रम को छोटे मूल्यांकन योग्य टुकड़ों में बाँट सकते हैं ^या अन्य आधार पात्रों के साथ बाँध सकते हैं ?
अर्जन जोहानसन

@ JobRrrJohansen हां, अच्छा काम है। मैं अभी एक समाधान पर काम कर रहा हूँ।
ग्रीम

आप उस सिकुड़े उदाहरण को TIO लिंक बना सकते हैं इसे ऑनलाइन आज़माएं!
अर्जन जोहान्सन

7
निवेदन: इसे "थोड़ा अलग दृष्टिकोण" बताएं
कैलक्यूलेटरफनलीन

32

पायथन 2, 7 वर्ण

exc="%\n

किसी भी पायथन 2 प्रोग्राम को इन 7 अक्षरों ( \nन्यूलाइन) का उपयोग करके एन्कोड किया जा सकता है।

मनमाने तार लगाना

हम %एक ही स्ट्रिंग पर बार-बार प्रतिस्थापन ऑपरेटर को लागू करके संघटन कर सकते हैं । उदाहरण के लिए, यदि a=1, b=2, c=3, "%d%%d%%%%d" % a % b % cहमें स्ट्रिंग देगा "123"। सौभाग्य से, पत्र execहमें पहुंच प्रदान करते हैं %xऔर %cजो मूल रूप से hex()और हैं chr()। जब %cतक हमारे पास आवश्यक संख्या है जो वर्णों का प्रतिनिधित्व करते हैं, तब तक हम किसी भी तार का निर्माण कर सकते हैं। हम execकीवर्ड का उपयोग करके इस स्ट्रिंग को अजगर कोड के रूप में निष्पादित कर सकते हैं ।

नंबर बना लें

हम तुलना के साथ बल्ले से पहुंच 0और 1अधिकार प्राप्त कर सकते हैं ( ==)। समवर्ती अंकों और मोडुलो के संयोजन के माध्यम से, उस संख्या का निर्माण संभव है 43जो +ASCII में प्रतिनिधित्व करता है। यह हमें हमारे कोड के लिए आवश्यक संख्याओं के निर्माण की अनुमति देता है।

एक साथ रखते हुए

मैंने इस स्पष्टीकरण में कई विवरणों को छोड़ दिया क्योंकि वे यह समझने में आवश्यक नहीं हैं कि इन बाधाओं के तहत कार्यक्रम कैसे लिखे जा सकते हैं। नीचे एक पायथन 2 कार्यक्रम है जो मैंने लिखा था कि किसी भी अजगर कार्यक्रम को एक कार्यात्मक समकक्ष संस्करण में परिवर्तित करता है जो केवल इन 7 वर्णों का उपयोग करता है। उपयोग की गई तकनीकें k द्वारा अराजकता वाले गोल्फ पर इस सबमिशन से प्रेरित हैं । कुछ सरल ट्रिक्स का उपयोग उचित सीमा के भीतर उत्पन्न कार्यक्रमों के आकार को बनाए रखने के लिए भी किया जाता है।

import sys

var = {
    43: 'e',
    'prog': 'x', # the program will be stored in this variable
    'template': 'c',
    0: 'ee',
    1: 'ex',
    2: 'ec',
    4: 'xe',
    8: 'xx',
    16: 'xc',
    32: 'ce',
    64: 'cc',
    'data': 'cx', # source program will be encoded here
}

unpacker = 'exec"".join(chr(eval(c))for c in {}.split())'.format(var['data'])

source = sys.stdin.read()
charset = sorted(list(set(source+unpacker)))
codepoints = map(ord, charset)

output = (
    # create template for joining multiple characters
    '{}="%c%%c%%%%c%%%%%%%%c"\n'.format(var['template']) +

    # create 1
    '{0}={1}=={1}\n'.format(var[1], var['template']) +

    # create 0
    '{}={}==""\n'.format(var[0], var['template']) +

    # create 3
    # store it at var[43] temporarily
    (
        'exec"{0}=%x%%x"%{2}%{2}\n' +
        'exec"{0}%%%%%%%%=%x%%x%%%%x"%{1}%{2}%{1}\n'
    ).format(var[43], var[0], var[1]) +

    # create 4
    # this step overwrites the value stored at var[0]
    (
        'exec"{1}=%x%%x"%{0}%{1}\n' +
        'exec"{1}%%%%=%x%%x"%{2}%{0}\n'
    ).format(var[43], var[0], var[1]) +

    # create 43
    'exec"{0}=%x%%x"%{1}%{0}\n'.format(var[43], var[0])
)

# create powers of 2
for i in [2, 4, 8, 16, 32, 64]:
    output += 'exec"{0}={1}%c{1}"%{2}\n'.format(var[i], var[i/2], var[43])

for i, c in enumerate(codepoints):
    # skip if already aliased
    if c in var:
        continue

    # generate a new name for this variable
    var_name = ''
    if i < 27:
        for _ in range(3):
            var_name += 'exc'[i%3]
            i /= 3
    else:
        i -= 27
        for _ in range(4):
            var_name += 'exc'[i%3]
            i /= 3
    var[c] = var_name

    # decompose code point into powers of two
    rem = c
    pows = []
    while rem:
        pows.append(rem&-rem)
        rem -= rem&-rem

    # define this variable
    front = 'exec"{}={}'.format(var[c], var[pows.pop()])
    back = '"'
    for i, p in enumerate(pows):
        front += '%'*(2**i) + 'c' + var[p]
        back += '%' + var[43]
    output += front + back + '\n'

# initialise the unpacker
output += 'exec"""{}=""\n"""\n'.format(var['prog'])
i = 0
length = len(unpacker)
while i < length:
    if (length-i) % 4 == 0:
        # concat 4 characters at a time
        w, x, y, z = [var[ord(unpacker[i+j])] for j in range(4)]
        output += 'exec"{}%c={}%%{}%%{}%%{}%%{}"%{}\n'.format(var['prog'], 
                    var['template'], w, x, y, z, var[43])
        i += 4
    else:
        output += 'exec"""{}%c="%%c"%%{}"""%{}\n'.format(var['prog'],
                    var[ord(unpacker[i])], var[43])
        i += 1

# encode source data
output += var['data'] + '="""'
output += '\n'.join(var[ord(c)] for c in source)
output += '"""\n'

# execute the program
output += 'exec"exec%c{}"%{}'.format(var['prog'], var[32])

print output

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


आप यह देखने के लिए कुछ जांच जोड़ सकते हैं कि क्या इनपुट प्रोग्राम पहले से ही अक्षरों के आवश्यक सेट तक सीमित है, और यदि हां, तो बस बिल्ली।
mbomb007

26

गणितज्ञ, ४ वर्ण

I[]

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

इनका उपयोग करके, हम कॉम्बिनेटर लॉजिक के S, Kऔर Iकॉम्बिनेटरों को लागू कर सकते हैं :

I -> II↦II
K -> II↦III↦II
S -> II↦III↦IIII↦II[IIII][III[IIII]]

इनके साथ एक वाक्यात्मक मुद्दा यह है कि इसकी बहुत कम पूर्ववर्तीता है जो अगर हम इन संयोजनकर्ताओं के तर्क को पारित करने का प्रयास करेंगे तो यह एक समस्या होगी। आप आमतौर Cपर कोष्ठक में कंघी बनाने वाले की तरह लपेटकर ठीक कर देंगे (C), लेकिन हमारे पास कोष्ठक नहीं हैं। हालाँकि, हम उपयोग कर सकते हैं Iऔर कुछ अन्य जादू में []लपेटने के लिए Cपर्याप्त रूप से उच्च मिसाल है जिसका उपयोग हम बाद में कर सकते हैं:

I[C][[I[[]]I]]

अंत में, एक आवेदन लिखने के लिए A x y z(जहां Aऊपर एक कोम्बिनेटर "कोष्ठक" दिखाया गया है, जैसा कि ऊपर दिखाया गया है, और x, या y, zइसका विघटन नहीं किया जा सकता है, या बड़े भाव हो सकते हैं), हम लिख सकते हैं:

A[x][y][z]

यह सवाल छोड़ देता है कि कोष्ठक-समतुल्य वास्तव में कैसे काम करता है। मैं इसे मोटे तौर पर समझाने की कोशिश करूँगा जिस क्रम में मैं इसके साथ आया था।

तो कुछ चीज़ों को समूहीकृत करने के लिए हमारे पास सिंटैक्टिक रूप से चीज़ है []। मैथेमेटिका में ब्रैकेट दो तरह से दिखाई देते हैं। या तो फ़ंक्शन इनवोकेशन के रूप में f[x], या एक इंडेक्सिंग ऑपरेटर के रूप में f[[i]](जो वास्तव में सिर्फ शॉर्टहैंड है Part[f, i])। विशेष रूप से इसका मतलब है कि न तो सिंटैक्स वैध है [C]और न ही [[C]]। हमें इसके सामने कुछ चाहिए। सिद्धांत रूप में यह कुछ भी हो सकता है। यदि हम उपयोग करते हैं Iतो हमारे पास पहले से मौजूद I[C]उदाहरण हैं। यह निर्विवाद रहता है, क्योंकि Iयह एक असमान कार्य नहीं है (यह एक कार्य नहीं है)।

लेकिन अब हमें Cफिर से निकालने के लिए किसी तरह की आवश्यकता है , क्योंकि अन्यथा इसका मूल्यांकन तब नहीं किया जाएगा जब हम इसके लिए एक तर्क पारित करने का प्रयास xकरते हैं।

यह वह जगह है जहाँ यह काम में आता f[[i]]है जिसका उपयोग मनमानी अभिव्यक्तियों के लिए किया जा सकता है f, न कि केवल सूचियों के लिए। यह मानते हुए कि fस्वयं रूप का है head[val1,...,valn], तब f[[0]]देता है head, f[[1]]देता है val1, f[[-1]]देता है , valnइत्यादि। इसलिए हमें 1या तो फिर -1से निकालने की जरूरत है C, क्योंकि या तो I[C][[1]]या I[C][[-1]]मूल्यांकन करना है C

हम एक मनमाने ढंग से अपरिभाषित प्रतीक से प्राप्त कर सकते1 हैं x, लेकिन ऐसा करने के लिए, हमें विभाजन के लिए एक और चरित्र की आवश्यकता होगी ( अपरिभाषित के लिए x/xदेता 1है x)। गुणा केवल गणित आपरेशन जो हम किसी भी अतिरिक्त वर्ण (सिद्धांत रूप में) के बिना काम कर सकता है, इसलिए हम कुछ मूल्य है कि देने के लिए गुणा किया जा सकता की जरूरत है -1या 1। यह इस कारण से समाप्त होता है कि मैंने विशेष रूप Iसे अपने पहचानकर्ताओं के लिए क्यों चुना है । क्योंकि Iअपने आप में काल्पनिक इकाई के लिए मैथेमेटिका का अंतर्निहित प्रतीक है।

लेकिन यह एक अंतिम समस्या है: हम वास्तवI में खुद से कैसे गुणा करते हैं ? हम सिर्फ IIइसलिए नहीं लिख सकते क्योंकि वह एक प्रतीक के रूप में प्राप्त होता है। हमें इन टोकनों को अलग करने की आवश्यकता है) किसी भी नए पात्रों का उपयोग करके उनके मूल्य और बी को बदलकर।

एक जादू का अंतिम बिट अनिर्दिष्ट व्यवहार का एक टुकड़ा है: f[[]](या समतुल्य Part[f]) वैध वाक्यविन्यास है और fखुद को वापस लौटाता है। तो बजाय गुणा करने का Iद्वारा I, हम गुणा I[[]]द्वारा I। ब्रैकेट्स डालने से गणितज्ञ को बाद में एक नए टोकन की तलाश होती है, और आवश्यकतानुसार I[[]]Iमूल्यांकन -1करता है। और इसी के साथ हम अंत करते हैं I[C][[I[[]]I]]

ध्यान दें कि हमारा उपयोग नहीं हो सकता है I[]। यह फ़ंक्शन का एक तर्कहीन आह्वान है I, लेकिन जैसा कि मैंने पहले कहा था Iकि यह एक फ़ंक्शन नहीं है, इसलिए यह निर्विवाद रहेगा।


अद्भुत जवाब।
पैट्रिक स्टीवंस

23

पायथन 2, 8 वर्ण

exc'%~-0

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

एक दोहरे उद्धरण चिह्न के साथ-साथ शून्य के अलावा किसी एक अंक का भी उपयोग किया जा सकता है। (अब मैं इसके बारे में लगता है कि, 1निश्चित रूप से बेहतर है क्योंकि आप इस्तेमाल कर सकते हैं हो सकता है, कम कार्यक्रमों में जिसके परिणामस्वरूप, 1, 11, और 111, साथ ही।)

यहाँ कार्यक्रम है print:

exec'%c%%c%%%%c%%%%%%%%c%%%%%%%%%%%%%%%%c'%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0%-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~0

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

आधार कार्यक्रम की आवश्यकता है

exec''

xकार्यक्रम में जोड़े गए प्रत्येक वर्ण की आवश्यकता होती है (चार गिनती):

  • % - 2**(n-1)
  • c - 1
  • - - ord(x)*2
  • ~ - ord(x)*2
  • 0 - 1

इसका अपवाद यह है कि एन्कोडेड प्रोग्राम को छोटा बनाने के लिए कुछ अनुकूलन / शॉर्टकट लिए जा सकते हैं, जैसे कि 48 के बजाय %'0'चरित्र का उपयोग करना , आदि।0-~

व्यावहारिक उपयोग (AKA गोल्फिंग): मैंने एक अतिरिक्त बाधा चरित्र का उपयोग किए बिना इस चुनौती को हल करने के लिए इस रणनीति का उपयोग किया।

चरित्र सूची और एक एनकोडर कार्यक्रम के लिए क्रेडिट: यहां

परिणामी कार्यक्रम आकार (अनुकूलन के बिना) पर एक कम बाध्य खोजने की जानकारी के लिए, यह टिप्पणी देखें ।

आवश्यक बाइट्स की संख्या बढ़ जाती है O(2**n), इसलिए यह विधि गोल्फ के लिए अनुशंसित नहीं है। इस स्रोत प्रतिबंध का उपयोग करने वाली एक रानी लंबे समय तक पागल होगी।


यदि केवल ऑपरेटर पूर्वता निष्पादित +या उसके -पहले %, हम एक चरित्र को निकाल सकते हैं।
mbomb007

यह ध्यान देने योग्य हो सकता है कि ट्यूरिंग-पूर्णता के लिए आपके कम वर्ण सेट में प्रत्येक पायथन प्रोग्राम का अनुवाद करने में सक्षम नहीं है। हालांकि मैं कल्पना करता हूं कि किसी execभी तरह का उपयोग किए बिना नियंत्रण प्रवाह की आवश्यक मात्रा प्राप्त करना कठिन होगा ।
मार्टिन एंडर

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

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

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

23

सी (अप्राप्य), २४ १ ) १३ अक्षर

aimn[]={};,1+

यह फॉर्म के सभी कार्यक्रमों को कवर करता है

main[]={<sequence of constants>};

... जहां स्थिरांक का क्रम (फॉर्म 1 + 1 + 1 ...) में आपके प्रोग्राम का मशीन कोड प्रतिनिधित्व होता है। यह मानता है कि आपका वातावरण सभी मेमोरी सेगमेंट को निष्पादित करने की अनुमति देता है (स्पष्ट रूप से tcc के लिए सही है [धन्यवाद @ डेनिस!] और NX बिट के बिना कुछ मशीनें)। अन्यथा, लिनक्स और ओएसएक्स के लिए आपको कीवर्ड को प्रस्तुत करना पड़ सकता है constऔर विंडोज के लिए आपको #pragmaसेगमेंट को निष्पादन के रूप में स्पष्ट रूप से चिह्नित करना पड़ सकता है ।

एक उदाहरण के रूप में, उपरोक्त शैली में लिखा गया प्रोग्राम Hello, World!लिनक्स और OSX पर x86 और x86_64 पर प्रिंट करता है।

main[]={111111111+111111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+11111+11111+11111+11111+11111+11111+11111+11111+111+11+11+11+11+11+11+1+1,1111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+11111+11111+11111+11111+11111+11111+1111+1111+1111+111+111+111+111+111+111,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+111111+111111+111111+111111+11111+11111+11111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+11+11+1+1+1+1+1+1+1,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+111+111+111+111+111+111+11+11+11+11+11+11+1+1+1+1,111111111+111111111+111111111+111111111+111111111+1111111+1111111+1111111+1111111+111111+111111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+11+11+11+11+1+1+1+1,111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+1111+1111+1111+111+111+111+111+111+11+11+11+11+11+11+1+1+1+1+1+1,111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+111+111+111+111+111+111+11+11+11+11+11+11+11+1,1111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+1111+1111+1111+1111+1111+1+1+1+1+1,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+11+11+1+1+1+1+1+1+1+1+1,1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+111111+111111+111111+111111+11111+11111+1111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+11+11+1+1+1+1+1,1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+111111+11111+11111+11111+11111+1111+1111+1111+1111+1111+111+11+1+1+1+1+1,1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+11111+111+111+111+111+1+1+1+1+1+1+1,1111111111+1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+11111+11111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+11+11+11+1+1+1,1111111111+111111111+111111111+111111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+111111+111111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+111+111+111+111+111+111+1+1+1+1+1+1,111111+111111+11111+11111+11111+11111+11111+11111+11111+1111+1111+1111+1111+1111+1111+1111+1111+111+111+111+11+11+11+11+11+11+11+11+11+11,11111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+111+111+111+111+111+11+11+11+11+11+11+11+1+1+1,111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+111+111+11+11+11+1,111111111+111111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+11111+11111+1111+1111+111+11+11+1+1+1+1+1,11111+11111+11111+11111+1111+1111+1111+1111+111+111+111+111+111+111+111+111+111+11+11+11+1+1+1+1+1};

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


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

2
@GB 32 बिट 0==1111111111+1111111111+1111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+111111111+11111111+11111111+11111111+11111111+11111111+11111111+1111111+1111111+1111111+1111111+1111111+111111+111111+111111+111111+11111+11111+11111+11111+11111+11111+11111+111+111+111+111+111+11+11+11+11+11+11+11+1
इनट के

3
tcc आपको बिना दूर जाने देता है consttio.run/nexus/…
डेनिस

8
@GB मुझे सिर्फ 0 का एक छोटा सा प्रतिनिधित्व है1==11
छत

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

20

रेटिना , 6 वर्ण

$%`{¶

साथ ही साथ लाइनफीड्स (0x0A)।

एक तरफ मैं हैरान हूं कि मैं इसे कम कर पा रहा था। दूसरी ओर, मैं शामिल किए जाने से बहुत दुखी हूं । प्रत्येक का $`{दो या तीन उद्देश्यों के लिए पुन: उपयोग किया जाता है, लेकिन एक साथ केवल एक ही उद्देश्य पूरा होता है। यह उन्हें बल्कि बेकार लगता है और थोड़ा दृष्टिकोण की लालित्य को नष्ट कर देता है। मुझे आशा है कि इस निर्माण को हरा देने का एक तरीका है।

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

सबसे पहले, हम का उपयोग किया जाएगा `और {के बजाय द्विआधारी वर्णमाला के लिए 0और 1। ये सुविधाजनक हैं, क्योंकि उन्हें रेगेक्स में भाग जाने की आवश्यकता नहीं है, लेकिन उनका अर्थ रेटिना के लिए या प्रतिस्थापन सिंटैक्स में है। मैं उपयोग कर रहा हूँ `के लिए 0और {के लिए 1है, लेकिन इस चुनाव मनमाने ढंग से है। इसके अलावा, हम, स्मृति में स्ट्रिंग (और प्रस्तुतियों) को उल्टा करने के लिए जा रहे हैं क्योंकि पिछले चरित्र के साथ काम करने के लिए हमें का उपयोग करने देता $और $`के बजाय ^और $', चरित्र पुन: उपयोग को अधिकतम।

यदि प्रारंभिक शब्द को निरूपित किया जाता है Sऔर iवें (उलट) उत्पादन को कहा जाता है , तो परिणामी कार्यक्रम इस तरह दिखेगा:pi


S
{`

{$
¶p1$%``
``$

{$
¶p2$%``
``$

{$
¶p3$%``
``$

...

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

आइए देखें कि कार्यक्रम क्या करता है:


S

हम शुरुआती शब्द को काम करने वाले स्ट्रिंग को शुरू करने से शुरू करते हैं।

{`

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

प्रत्येक उत्पादन दो चरणों द्वारा संसाधित होता है। सबसे पहले हम इस मामले से निपटते हैं कि अग्रणी (या हमारे मामले में अनुगामी) प्रतीक है {, जिस स्थिति में हम उत्पादन का उपयोग करते हैं:

{$
¶pi$%``

रेग्ज केवल मेल खाता है यदि स्ट्रिंग में समाप्त होता है {। अगर ऐसा है, तो हम इसे बदल देते हैं:

  • एक लाइनफीड ( )। हम केवल कार्यशील स्ट्रिंग की अंतिम पंक्ति के साथ काम कर रहे हैं, इसलिए यह प्रभावी रूप से अब तक काम करने वाले तार को छोड़ देता है (यही कारण है कि कार्यक्रम का मेमोरी उपयोग बढ़ेगा और बढ़ेगा)।
  • वर्तमान उत्पादन ( ), जिसे हम यहां कार्यशील स्ट्रिंग (जहां चक्रीय टैग प्रणाली इसे जोड़ते हैं) के लिए तैयार कर रहे हैं।pi
  • पिछला शेष कार्य स्ट्रिंग ( $%`)। यही कारण है कि हमें सम्मिलित करने की आवश्यकता है : $%`मैच के बचे हुए सभी चीज़ों को उठाता है, लेकिन केवल एक ही पंक्ति पर। इसलिए, यह उन सभी कबाड़ को नहीं देखता है जिन्हें हमने पहले की प्रस्तुतियों से छोड़ा है। यह ट्रिक हमें काम करने वाले स्ट्रिंग के अंत में कुछ जोड़ने की अनुमति देता है , जो काम करने वाले स्ट्रिंग की शुरुआत में कुछ डालने के लिए होता है, जैसे कि कुछ का उपयोग करने के लिए (.+)और $1जो हमें आवश्यक वर्णों की संख्या को काफी उड़ा देगा।
  • एक एकल बैकटिक ( `)। यह प्रभावी रूप से बदल देता है {( 1-symbol) हम एक साथ मिलान `( 0-symbol) ताकि अगले चरण पता करने के लिए हम पहले से ही वर्तमान उत्पादन संसाधित या नहीं की जरूरत नहीं है।

प्रत्येक उत्पादन का दूसरा भाग तब तुच्छ मामला है जहां उत्पादन छोड़ दिया जाता है:

``$

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


20

जावा 7, 18 17 वर्ण

\bcdefu0123456789

सभी जावा स्रोत कोड को यूनिकोड कोड बिंदुओं तक कम किया जा सकता है। "a" की आवश्यकता नहीं है क्योंकि यह केवल इसके लिए उपयोग किया जाता है *:jJzZ। तारांकन का उपयोग गुणन या ब्लॉक टिप्पणियों के लिए किया जाता है। गुणा केवल बार-बार जोड़ा जाता है और आप इसके बजाय एकल लाइन टिप्पणियों का उपयोग कर सकते हैं (या बस उन्हें छोड़ दें)। बृहदान्त्र का उपयोग टर्नरी संचालकों के लिए किया जाता है, जिसे आप इसके लिए एक if स्टेटमेंट का उपयोग कर सकते हैं, और foreach loops, जिसे लूप्स के लिए सामान्य से बदला जा सकता है। j और z जावा में किसी भी कीवर्ड का हिस्सा नहीं हैं।

किसी भी अन्य चरित्र को हटाने का प्रयास करने से हमें जावा बॉयलर प्लेट में कम से कम एक वर्ण जोड़ने की आवश्यकता होती है class a{public static void main(String[]a){}}। निचे देखो:

1 -> a (which has already been removed)
2 -> r (required for "String")
3 -> S (required for "String")
4 -> t (required for "static")
5 -> S (required for "String")
6 -> v (required for "void")
7 -> g (required for "String")
8 -> ( (required for "main(String[]a)"
9 -> i (required for "static")
b -> { (required for "class a{")
c -> l (required for "class")
d -> } (required for "(String[]a){}}")
e -> n (required for "main")
f -> o (required for "void")

यहाँ हैलो वर्ल्ड प्रोग्राम के साथ एक उदाहरण दिया गया है इसे ऑनलाइन आज़माएं!

जावा 8, 16 वर्ण

\bdefu0123456789

इसे इंगित करने के लिए ais523 का धन्यवाद। जावा 8 इंटरफेस को स्थिर तरीकों की अनुमति देता है जिसका अर्थ है कि हम "सी" को छोड़ सकते हैं क्योंकि हमें "एल" के लिए "क्लास" में इसकी आवश्यकता नहीं है। "c" का उपयोग तब किया जाता ,<lL\|है जब हम "a" हटाए जाने की तुलना में कुछ अधिक जावा कार्यक्षमता खो देते हैं, लेकिन हमारे पास अभी भी पूरा करने के लिए पर्याप्त है। इसे ऑनलाइन आज़माएं!


3
निश्चित रूप से, यह पता लगाना कि हेक्साडेसिमल अंकों में से किसको छोड़ा जा सकता है जावा में इसे हल करने का दिलचस्प हिस्सा है? :)
मार्टिन एंडर

@MartinEnder बिल्कुल। मैं इस पर काम कर अधिक पर योजना जब मैं कुछ समय मिलता है
प्रहार

6
और मुझे जो कुछ लिखने के लिए तैयार था Java, 127 characters... नाइस वन, पोक;)
ओलिवियर ग्राईगोइयर

मेरे उत्तर में आवश्यक वर्णों के आधार पर , मुझे विश्वास नहीं है कि किसी अन्य हेक्स अंकों को हटाया जा सकता है।

3
यदि आप जावा 8 पर स्विच करते हैं, तो आप इसे 16 में कर सकते हैं; जावा 8 इंटरफेस को स्थिर तरीकों की अनुमति देता है, जिससे आप ड्रॉप कर सकते हैं c(सभी अक्षर interfaceअभी भी नहीं aया cआपके हेक्स शाब्दिक के साथ सुलभ हैं )।

19

भूलभुलैया , 5 अक्षर

~{}

प्लस लाइनफीड (0x0A) और रिक्त स्थान (0x20)।

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

इस कमी के दौरान एक महत्वपूर्ण आवेग यह होगा कि प्रत्येक कार्यक्रम (या उपप्रोग्राम) के परिणामस्वरूप एक भूलभुलैया (या उपप्रोग्राम) होगा जो एक ही पंक्ति पर शुरू और समाप्त होता है, और एक समान संख्या में स्तंभों को फैलाता है।

भूलभुलैया के दो ढेर हैं जो शुरू में एस के एक अनंत (अंतर्निहित) राशि से भरे हुए हैं 0{और }इन ढेर के बीच शीर्ष मूल्य को स्थानांतरित करें। यदि हम मुख्य स्टैक के शीर्ष को वर्तमान "सेल" मानते हैं, तो इन दो स्टैक को स्मॉलफैक द्वारा उपयोग किए गए अनंत टेप के दो अर्ध-अनंत हिस्सों के रूप में देखा जा सकता है। हालांकि, स्टैक पर प्रत्येक टेप मान की दो प्रतियां रखना अधिक सुविधाजनक होगा, ताकि ऊपर उल्लिखित सुनिश्चित किया जा सके। इसलिए <और क्रमशः >अनुवाद किया जाएगा {{और }}, (यदि आप चाहें तो आप उन्हें स्वैप कर सकते हैं)।

सेल मानों की अनुमति देने के बजाय 0और 1, हम उपयोग कर रहे हैं 0और -1, जिसके साथ हम ~(बिटवाइस नकार) के बीच टॉगल कर सकते हैं । ट्यूरिंग-पूर्णता के उद्देश्यों के लिए सटीक मान मायने नहीं रखते हैं। हमें स्टैक पर मूल्य की दोनों प्रतियों को बदलना होगा, जो हमें फिर से एक समान लंबाई का अनुवाद देता है: *बन जाता है ~}~{

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

सबसे पहले, ध्यान दें कि ~~एक नो-ऑप है, क्योंकि दोनों ~प्रभावी रूप से रद्द करते हैं। हम इसका उपयोग कोड में मनमाने ढंग से लंबे रास्तों के लिए कर सकते हैं, जब तक कि उनकी लंबाई समान है। अब हम निम्नलिखित निर्माण का उपयोग AA[BB]CCभूलभुलैया में अनुवाद करने के लिए कर सकते हैं (मैं दोहरे अक्षरों का उपयोग कर रहा हूं ताकि लेबिरिंथ में प्रत्येक स्निपेट का आकार समरूप हो, जैसा कि हमलावर द्वारा गारंटी दिया गया है):

      ~~~~
      ~  ~~~
AA~~..~~~~ ~CC
   ~     ~
   ~     ~
   ~     ~
   ~~~BB~~

यहां, ..एक उपयुक्त संख्या है, ~जिसकी चौड़ाई से मेल खाता है BB

फिर, ध्यान दें कि निर्माण की चौड़ाई भी बनी हुई है।

अब हम इस माध्यम से जा सकते हैं कि यह लूप कैसे काम करता है। कोड के माध्यम से दर्ज किया गया है AA। पहला ~~कुछ नहीं करता है और हमें जंक्शन तक पहुंचने देता है। यह मोटे तौर पर से मेल खाती है [:

  • यदि वर्तमान सेल मान शून्य है, तो आईपी सीधे आगे जारी रहता है, जो अंततः छोड़ देगा BB..हिस्सा अभी भी नो-सेशन है। फिर हम ~दूसरे जंक्शन पर सिंगल पहुंचते हैं । अब हम जानते हैं कि वर्तमान मान गैर-शून्य है, इसलिए आईपी उत्तर को मोड़ लेता है। यह शीर्ष पर मोड़ के चारों ओर जाता है, जब तक कि यह छह के बाद किसी अन्य जंक्शन तक नहीं पहुंचता ~। तो उस बिंदु पर वर्तमान मूल्य अभी भी शून्य नहीं है और आईपी फिर से पूर्व की ओर बढ़ने की बारी लेता है CC। ध्यान दें कि तीनों वापसी ~से पहले CCवर्तमान मूल्य 0, क्योंकि यह तब होना चाहिए जब लूप छोड़ दिया गया था।
  • यदि लूप की शुरुआत में वर्तमान सेल मान गैर-शून्य है, तो आईपी दक्षिण की ओर मुड़ता है। ~पहुँचने से पहले यह छह और चलता है BB(जो कुछ नहीं करते हैं), और फिर ~अगले जंक्शन पर पहुँचने से पहले एक और छह । यह मोटे तौर पर से मेल खाती है ]
    • यदि वर्तमान सेल शून्य है, तो आईपी उत्तर की ओर बढ़ता रहता है। अगला ~मान को गैर-शून्य बनाता है, ताकि आईपी इस दूसरे जंक्शन को ले जाए, जो उस मामले के साथ पथ को विलय कर देता है जो लूप पूरी तरह से छोड़ दिया गया था। फिर, तीनों ~तक पहुँचने से पहले मूल्य शून्य पर लौट आते हैं CC
    • यदि वर्तमान सेल गैर-शून्य है, तो आईपी पश्चिम की ओर मुड़ता है। ~अगले जंक्शन से पहले हैं , जिसका अर्थ है कि इस बिंदु पर वर्तमान मूल्य शून्य है ताकि आईपी पश्चिम में जाता रहे। फिर ~आईपी ​​के प्रारंभिक जंक्शन पर दोबारा पहुंचने से पहले एक विषम संख्या होगी , ताकि मान वापस आ जाए -1और आईपी अगले पुनरावृत्ति में दक्षिण की ओर चला जाए।

यदि प्रोग्राम में कोई लूप होता है, तो सबसे पहले AAप्रोग्राम के शीर्ष पर विस्तारित करने की आवश्यकता होती है ताकि आईपी को शुरू करने के लिए सही सेल मिल जाए:

~     ~~~~
~     ~  ~~~
AA~~..~~~~ ~CC
   ~     ~
   ~     ~
   ~     ~
   ~~~BB~~

वह यह है कि। ध्यान दें कि इस कमी के परिणामस्वरूप होने वाले कार्यक्रम कभी समाप्त नहीं होंगे, लेकिन यह ट्यूरिंग-पूर्णता (नियम 101 या फ्रैक्ट्रन पर विचार) की आवश्यकताओं का हिस्सा नहीं है।

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

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


19

हास्केल, 5 7 वर्ण

()\->=;

एक कार्यात्मक भाषा के रूप में हास्केल के पास लैम्ब्डा है, इसलिए लैम्बडा कैलकुलस का अनुकरण करना आसान है। लंबोदर के लिए वाक्य विन्यास है, इसलिए हमें कम से कम पात्रों की आवश्यकता है । इसके अतिरिक्त, हमें मनमाने ढंग से लंबोदर अभिव्यक्ति बनाने में सक्षम होने के लिए एक असीमित मात्रा में चर प्रतीकों की आवश्यकता है। सौभाग्य से हम इस बात के लिए किसी भी नए पात्रों की जरूरत नहीं है, क्योंकि , , , ..., सभी वैध चर नाम हैं। वास्तव में, कोष्ठक के अंदर का हर संयोजन एक वैध चर नाम है, केवल और , के अपवाद के साथ , जो लंबोदर अभिव्यक्तियों के लिए आरक्षित हैं, और , जो एक पंक्ति टिप्पणी शुरू करता है।(\variable->body)argument()\->
(>)(>>)(>>>)\->\->--

उदाहरण:

  • एस = को (\(>)(\\)(-)->(>)(-)((\\)(-)))प्रकार(t2 -> t -> t1) -> (t2 -> t) -> t2 -> t1
  • के = (\(>)(-)->(>))प्रकारt -> t1 -> t
  • I = (\(>)->(>))प्रकारt -> t

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

(>)=(\(-)->(-)((>)(-)));   -- equivalent to: f =(\ x -> x ( f  x ));

इस घोषणा के साथ हमारे लैम्ब्डा पथरी ट्यूरिंग पूरा, फिर भी जोड़ा होने हो जाता है =और ;, हम अब और lambdas की जरूरत नहीं है के रूप में आप में देख सकते हैं nimi का जवाब जो सिर्फ का उपयोग करता है ()=;


क्या इसे तकनीकी रूप से बिना संकलन के समय के नहीं हटाया जाएगा main?
पायरुलेज़

4
बस टाइप किए गए SKI कॉम्बीनेटर कैलकुलस ट्यूरिंग-पूर्ण नहीं है; आपको उसके लिए एक लाइप्ड लैम्ब्डा कैलकुलस की आवश्यकता है। दुर्भाग्य से, जैसा कि आपके प्रदर्शनों का उल्लेख है, हस्केल डिफ़ॉल्ट रूप से कोड पर एक टाइप की गई व्याख्या करता है।

@PyRulez डिफ़ॉल्ट नियमों के अनुसार मैंने मान लिया कि कार्य स्वीकार्य हैं।
लकोनी

@ ais523 एसकेआई कॉम्बिनेटर सिर्फ एक उदाहरण हैं, दिए गए नोटेशन का उपयोग करके मनमाने ढंग से लंबोदर शर्तों का निर्माण किया जा सकता है, जैसे चर्च के अंक और उन पर कार्य।
लैकोनी

@ ais523 लैंबडा कैलकुलस टाइप करने वाले कितने कॉम्बीनेटर को पूरा करने की आवश्यकता है? मुझे लगता है कि आपको बस वाई कॉम्बिनेटर की आवश्यकता है, है ना?
PyRulez

18

CJam, 3 वर्ण

)मार्टिन एंडर के सुझाव के अनुसार हटाया गया

'(~

एक उदाहरण के रूप में दिए गए पायथन के समान।

'~आप का उपयोग कर ~चरित्र प्राप्त कर सकते हैं । फिर उपयोग करते हुए (, आप जो भी चरित्र चाहते हैं उसे प्राप्त करने के लिए इसे घटा सकते हैं ( ~अंतिम मुद्रण योग्य ASCII वर्ण)। ~सामान्य CJam कोड के रूप में किसी भी स्ट्रिंग को विकसित करता है। चरित्र प्राप्त करके [(decrementing के माध्यम से ~) स्ट्रिंग्स का निर्माण किया जा सकता है , इसे eval'ing, अन्य वर्णों के कुछ अनुक्रम डालकर, फिर चरित्र का eval'ing ]। इसके माध्यम से, आप केवल तीन अक्षरों का उपयोग करके किसी भी CJam प्रोग्राम का निर्माण और क्रियान्वयन कर सकते हैं।

केवल उपयोग करके 2 + 2 की गणना करना '(~


एक और चुनौती के लिए, किसी ने एक प्रोग्राम बनाया जो किसी भी cjam प्रोग्राम को लेता है और स्वचालित रूप से इसे इस सबसेट पर संकलित करता है। मेरी इच्छा है कि मैं इसे पा
सकूं

1
मैं 2 + 2 प्रोग्राम को महत्वपूर्ण रूप से पूरा करने में कामयाब रहा'~((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((~'~(((((((((((((((((((((((((((((((~'~(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((~
Zwei

@ ज़ेवी महान, जो आपके नाम पर फिट बैठता है
क्रोमियम

18

ब्रेन-फ्लैक , 6 वर्ण

(){}[]

ब्रेन-फ्लैक एक न्यूनतम भाषा है जिसमें केवल 8 उपलब्ध अक्षर हैं। हालांकि यह साबित किया जा सकता है कि ब्रेन-फ्लैक का एक उपसमूह मौजूद है जो केवल 6 वर्णों का उपयोग करके ट्यूरिंग पूर्ण है।

पहली बात हम ब्रेन-फ्लैक के केवल एक ढेर के साथ एक मिन्स्की मशीन को लागू करेंगे। हम साबित कर सकते हैं कि एक Minsky मशीन केवल एक ढेर के साथ संभव है हम दिखा सकते हैं कि ब्रेन-आलोचना ट्यूरिंग के बिना पूरा हो गया है <>और []nilads। यह किसी भी वर्ण को तुरंत नहीं बचाएगा, लेकिन भविष्य में जब हम दिखाएंगे कि <...>यह आवश्यक नहीं है।

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

  • एक रजिस्टर में वृद्धि

  • यदि गैर-शून्य गिरावट अन्यथा एक निर्दिष्ट निर्देश में संक्रमण

ब्रेन-फ्लैक में एक गोटो संरचना स्थापित करने के लिए हम निम्नलिखित स्निपेट का उपयोग कर सकते हैं:

(({}[()])[(())]()){(([({}{})]{}))}{}{(([({}{}(%s))]{}))}{}

यह काउंटर को घटाएगा और %sशून्य होगा। इन जंजीरों का एक गुच्छा हमें ढेर पर एक नंबर लगाने की अनुमति देगा जो यह संकेत देगा कि हम किस लाइन को गोटो करना चाहते हैं। इनमें से प्रत्येक स्टैक के शीर्ष में कमी करेगा, लेकिन उनमें से केवल एक ही वास्तव में कोड चलाएगा।

हम अपने Minsky मशीन निर्देशों के सभी के लिए एक आवरण के रूप में इसका उपयोग करते हैं।

स्टैक को स्विच किए बिना किसी विशेष रजिस्टर को बढ़ाना बहुत आसान है। यह इस सूत्र के साथ प्राप्त किया जा सकता है:

"({}<"*n+"({}())"+">)"*n

उदाहरण के लिए 3 रजिस्टर बढ़ाने के लिए हम निम्नलिखित कोड लिखेंगे:

({}<({}<({}<({}())>)>)>)

अब हमें बस दूसरा ऑपरेशन लागू करना होगा। ब्रेन-फ्लैक में एक संख्या शून्य होने पर जाँच करना बहुत आसान है:

(({})){(<{}%s>)}{}

%sयदि केवल शून्य शून्य है, तो निष्पादित करेगा । इस प्रकार हम अपना दूसरा ऑपरेशन कर सकते हैं।

चूँकि Minsky Machines ट्यूरिंग कम्प्लीट ब्रेन-फ्लैक है, ट्यूरिंग कम्प्लीट ट्यूरिंग विदाउट द ऑपरेशन <>और []ऑपरेशन्स।

हालाँकि हमने अभी तक वर्णों की संख्या कम नहीं की है <...>और [...]अभी भी उपयोग में हैं। इसे सरल प्रतिस्थापन के साथ फिर से बनाया जा सकता है। चूंकि <...>वास्तव [(...)]{}में सभी मामलों में बराबर है । इस प्रकार ब्रेन-फ्लैक ट्यूरर्स <और >पात्रों के उपयोग के बिना पूरा हो रहा है (साथ ही सभी नो-ऑप्स)।


"क्योंकि <...>और [...]अभी भी उपयोग में हैं।" हालाँकि, आपने हटाया नहीं [...]। कृपया ठीक करें।
कैलक्यूलेटरफैनलाइन

प्रश्न: क्या [...]वास्तव में आवश्यक है? पुशिंग 0 के साथ शुरू में किया जा सकता है ({})(लेकिन यह एक खाली स्टैक पर निर्भर करता है, इसलिए 0s को सावधानीपूर्वक फेरबदल करना होगा) मुख्य समस्या बिना एक्सेस के स्टैक से नीचे जाने में सक्षम हो रही है <...>(जिसे अब अनुकरण नहीं किया जा सकता)
कैलक्यूलेटरफ्लीन

16

> <> , 3 वर्ण

> <> के साथ 3 में उल्लेखनीय है 1p-, जो करते हैं:

1          Push 1
p          Pop y, x, c and put the char c in cell (x, y) of the codebox
-          Subtraction: pop y, x and push x-y

pप्रतिबिंब प्रदान करता है, कोडबॉक्स में चार्ट रखकर 2 डी स्रोत कोड को संशोधित करता है। साथ 1-आप के बाद से ढेर पर किसी भी संख्या को धक्का कर सकते हैं, 1-घटाता एक और 111-1--( x-(1-1-1) = x+1) एक कहते हैं।

एक बार जब सभी 1p-कमांड निष्पादित हो जाते हैं, तो निर्देश सूचक चारों ओर घूमता है, जिससे इसे "वास्तविक" कोड निष्पादित करने की अनुमति मिलती है।

एक उदाहरण कार्यक्रम जो फाइबोनैचि संख्याओं की गणना करता है ( इस उत्तर से ) है:

111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1--11-p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11-1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--11p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1-1--1p111-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1--111-1-1-1-1-1-1-1-1-1-1-1-1-1-1--1p

इसे ऑनलाइन आज़माएं! एक बार सभी 1p-कमांड निष्पादित हो जाने के बाद, कोडबॉक्स इस तरह दिखता है:

01aa+v1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1-1- ...
@+&1->:?!;&:nao:

vपहली पंक्ति के बाद सब कुछ को छोड़कर , यह एक मानक फाइबोनैचि> <> कार्यक्रम है।


13

बैश, 9 अक्षर

01456\$ '

बैश के पास $'\nnn'अपने अष्टाध्यायी मूल्यों के साथ पात्रों को दर्ज करने के लिए एक वाक्यविन्यास है। हम evalइस प्रारूप में कमांड दर्ज कर सकते हैं $'\145\166\141\154'। हम पहले वांछित परिणाम को इसके अष्टाधारी मूल्यों में बदल देते हैं। फिर हम सामने वाले को $(())जोड़ते हुए कहा कि अष्टाधारी मानों का उपयोग करते हुए और घटाव करते हुए कहा कि 0, 1, 4, 5, और 6 के अलावा अन्य अंकों का उपयोग करते हुए किसी भी अष्टाधारी मूल्यों को परिवर्तित करते हैं eval। अपने अंतिम चरण में, हम एक evalऔर जोड़ते हैं और कोष्ठक और ऋण चिह्न को अपने अष्टाधारी मानों में परिवर्तित करते हैं। इस पद्धति का उपयोग करके हम किसी भी bash कमांड को निष्पादित कर सकते हैं, इसलिए यह सबसेट पूरा हो गया है।

उदाहरण:

dc हो जाता है

$'\144\143' जो बन जाता है

$'\145\166\141\154' \$\'\\144\\$((144-1))\' जो बन जाता है

$'\145\166\141\154' $'\145\166\141\154' $'\$\\\'\\\\144\\\\$\050\050144\0551\051\051\\\''


12

हादसा , 2 पात्र

इससे कोई फर्क नहीं पड़ता कि आप कौन से दो अक्षर चुनते हैं; दो सप्तक का कोई भी संयोजन ट्यूरिंग-इन-इंसीडेंट है।

वास्तव में यह साबित करना जितना आप उम्मीद कर सकते हैं उससे कहीं अधिक कठिन है, और लेखन के समय, घटना के बारे में Esolang पर चर्चा पृष्ठ समस्या के लिए समर्पित है। मैं नीचे सरलतम ज्ञात प्रमाण का सारांश देने की कोशिश करूँगा, हालाँकि।

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

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


11

रेटिना , 3 वर्ण

{`

और न्यूलाइन।

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

लागू करने के लिए हमारी लक्ष्य भाषा थ्यू का एक निर्धारक संस्करण है (टी-पूर्णता के लिए नॉनडेटर्मिनिज़म आवश्यक नहीं है; यह सही है कि जिस तरह से मूल्यांकन आदेश का उपयोग किया जाता है, वह सही ढंग से काम करने के लिए एक थ्यू प्रोग्राम लिखना संभव है)। मूल विचार में संकलित pattern::=replacementकरना है

`pattern
replacement

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

बेशक, इसका मतलब यह है कि हमें थू ट्यूरिंग को सिर्फ {और सिर्फ `पैटर्न और प्रतिस्थापन के साथ साबित करने की आवश्यकता है , लेकिन यह काफी सरल है; हम ascii कोड n के साथ एक वर्ण को प्रतिस्थापित करते हैं `, n +1 {और दूसरा `। एक पैटर्न के लिए कहीं भी, लेकिन चरित्र सीमाओं पर मिलान करना स्पष्ट रूप से असंभव है, इसलिए यह मूल कार्यक्रम के समान ही काम करेगा।


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

1
ठीक है। यह निश्चित रूप से ट्यूरिंग-पूर्णता को प्रभावित नहीं करता है, (क्योंकि एक अनंत लूप जो आंतरिक स्थिति को नहीं बदलता है, एक कार्यक्रम के कम्प्यूटेशनल वर्ग में योगदान नहीं कर सकता है)।

10

ब्रेकीलॉग , 5 अक्षर

~×₁↰|

वर्णों का यह सबसेट हमें फ्रैक्ट्रन के एक संस्करण को लागू करने की अनुमति देता है जिसमें केवल वही संख्याएं दिखाई दे सकती हैं जो पुनर्मिलन के उत्पाद हैं (यानी संख्याओं के उत्पाद जो केवल अंक 1 का उपयोग करके दशमलव में लिखे जा सकते हैं)। (सबस्क्रिप्ट के रूप में एक पूर्णांक के साथ) उस पूर्णांक द्वारा वर्तमान मान को विभाजित करता है, लेकिन केवल अगर यह बिल्कुल विभाजित करता है (अन्यथा यह "विफल" होता है और चलाने के लिए दूसरे मामले की तलाश करता है; |मामलों को अलग करता है)। ×हमें एक पूर्णांक द्वारा गुणा करें। इसलिए ~×₁|हम फ्राट्रान निष्पादन के एक चरण को लागू कर सकते हैं। फिर हमें नए वर्तमान मूल्य पर पूरे कार्यक्रम को फिर से चलाने, पुनरावृत्ति करने देता है। यहां एक बहुत ही सरल फ्रैक्ट्रन कार्यक्रम ( 11111111111111111111111/111) का उदाहरण दिया गया है जिसका अनुवाद ब्रिचलॉग में किया गया है।

तो क्या यह ट्यूरिंग पूर्ण है? हम सभी को फ्रैक्ट्रन ट्यूरिंग पूरा करने की आवश्यकता है, प्राइम नंबरों की एक पर्याप्त बड़ी मात्रा है (फ्रैक्चरन में ट्यूरिंग पूरी भाषा के लिए एक दुभाषिया लिखने के लिए पर्याप्त है)। इसमें पाँच सिद्ध और चार संदिग्ध हैंपुनर्मिलन के अलावा, संभवतः, संभवतः, जिन्हें अभी तक खोजा नहीं गया है। यह वास्तव में इस मामले में हमारी जरूरत से ज्यादा है। कार्यक्रम सही से बायीं संभावनाओं की जाँच करता है, इसलिए हम एक प्राइम को एक इंस्ट्रक्टर पॉइंटर के रूप में और दो अधिक काउंटर्स के रूप में उपयोग कर सकते हैं, केवल तीन प्राइम्स (एक अच्छी बात) के साथ ट्यूरिंग पूर्णता का प्रदर्शन करते हैं, क्योंकि यह हमें 2, 19 के साथ पुनर्मिलन का उपयोग करने देता है। , और 23 अंक, 317 या 1031 अंकों के साथ सिद्ध-लेकिन-कष्टप्रद-बड़े रिपुनिट्स का सहारा लिए बिना, जो स्रोत कोड को लिखने में काफी कठिन बना देगा)। इससे दो काउंटरों (ट्यूरिंग-पूर्णता के लिए पर्याप्त) के साथ मिन्स्की मशीन को लागू करना संभव हो जाता है।

यहां बताया गया है कि संकलन विशेष रूप से कैसे काम करता है। हम अपने Minsky मशीन कार्यान्वयन के लिए निम्नलिखित दो आदेशों का उपयोग करेंगे (यह ट्यूरिंग पूर्ण ज्ञात है), और प्रत्येक कमांड में एक लेबल के रूप में एक पूर्णांक होगा:

  • लेबल एल: यदि काउंटर {ए या बी} शून्य है, तो गोटो एक्स। अन्यथा इसे घटाएं और गोटो वाई।
  • लेबल एल: वृद्धि काउंटर {ए या बी}, फिर गोटो जेड।

हम चुनते हैं कि हर में 11 की शक्तियों को रखने के माध्यम से कौन सी कमांड चलती है, पहले उच्चतम शक्तियां; 11 का घातांक कमांड का लेबल है। इस तरह, पहला अंश जो मेल खाता है वह वर्तमान में निष्पादित कमांड होगा (क्योंकि पिछले वाले उन सभी 11 से विभाजित नहीं कर सकते हैं)। एक कमी आदेश के मामले में, हम क्रमशः काउंटर ए या बी के लिए 1111111111111111111 या 11111111111111111111111 के एक कारक को काउंटर में रखते हैं, और उस कारक के बिना किसी अन्य के साथ इसका पालन करते हैं; "गिरावट" मामले को पहले आदेश द्वारा लागू किया जाएगा, दूसरे द्वारा "शून्य" मामला। इस बीच, "गोटो" को अंश में 11 की एक उचित शक्ति द्वारा नियंत्रित किया जाएगा, और अंश में 1111111111111111111 या 11111111111111111111111 के कारक के माध्यम से "वेतन वृद्धि"।


किसी विशेष कारण से आप युग्मक कॉपीप्राइम पुनर्खरीद का उपयोग नहीं कर सकते हैं?
कैलक्यूलेटरफिलीन

@ कैलाकुलरफेलिन: नहीं, लेकिन मैंने उनके बारे में तब तक नहीं सोचा जब तक कि मुझे पहले से ही निर्माण नहीं मिल गया जिसकी उन्हें आवश्यकता नहीं थी। यह निश्चित रूप से इस चरित्र सेट के साथ लिखे गए गोल्फिंग कार्यक्रमों में मदद करेगा।

इसके अलावा, सभी पुनर्मिलन> 1 जोड़ीदार कॉपीराइम (इसके बारे में सोचें)
कैलक्यूलेटरफल

@ कैलाकुलरफलाइन: नहीं, वे नहीं हैं। 111 और 111111 दोनों स्पष्ट रूप से स्पष्ट रूप से 3 से विभाज्य हैं।

* कोई भी पुनर्मिलन एक और पुनर्मिलन को विभाजित नहीं करता है
कैलक्यूलेटरफैनलाइन

10

Befunge-98, 3 वर्ण

जहां तक ​​मुझे पता है, Befunge-98 को पूर्ण रूप से ट्यूरिंग माना जाता है, इसलिए हमें केवल यह दिखाने की आवश्यकता है कि केवल तीन वर्णों का उपयोग करके किसी भी Befunge-98 प्रोग्राम को कैसे उत्पन्न किया जा सकता है। मेरा प्रारंभिक समाधान निम्नलिखित चार वर्णों पर निर्भर करता है:

01+p

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

हालाँकि, जैसा कि Sp3000 ने बताया, आप वास्तव में सिर्फ तीन पात्रों के साथ मिल सकते हैं:

1-p

किसी भी नकारात्मक संख्या की गणना शुरू करके 1और फिर बार-बार घटाकर की जा सकती है 1(उदाहरण के लिए, -3 होगी 11-1-1-1-)। फिर किसी भी सकारात्मक संख्या को 1 से n-n घटाकर दर्शाया जा सकता है, जहां 1-n एक ऋणात्मक संख्या है जिसे हम पहले से ही जानते हैं कि कैसे संभालना है (उदाहरण के लिए, 4 = 1 - (- 3), जो होगा 111-1-1-1--)।

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

एक उदाहरण के रूप में, यहां एक बूटलोडर है जो 2 + 2 का योग करने के लिए आवश्यक Befunge कोड उत्पन्न करता है और परिणाम का उत्पादन करता है: 22+.@

और थोड़ा और जटिल उदाहरण के लिए, यह "हैलो वर्ल्ड" है: "!dlroW olleH"bk,@


यह एक पॉलीग्लॉट है, समान वर्णों का उपयोग> <> और इसके डेरिवेटिव के लिए किया जा सकता है। अच्छा काम!
सोक

2
Befunge-98 के साथ 3 में संभव है 1p-के रूप में अच्छी तरह से
Sp3000

@ Sp3000 बेशक हां! मुझे यकीन था कि इसे 3 वर्णों तक ले जाने का एक तरीका रहा होगा। धन्यवाद।
जेम्स होल्डरनेस

9

रूबी, 8 वर्ण

eval"<1+

पायथन जवाब से प्रेरित है

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

  • eval का उपयोग एक मनमाना स्ट्रिंग को निष्पादित करने के लिए किया जा सकता है।
  • "<1+ किसी भी स्ट्रिंग को बनाने के लिए आवश्यक वर्णों का न्यूनतम सेट है

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

eval ""<<111+1<<11+11+11+1<<111<<11+11+11+1

वास्तव में इसके बराबर है

eval ""<<112<<34<<111<<34

जो स्ट्रिंग का मूल्यांकन करता है

p"o"

8

OCaml, 9 वर्ण

fun->()`X

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

एस संयोजक:

fun(f)(u)(n)->f(n)(u(n)) प्रकार के साथ ('a -> 'b -> 'c) -> ('a -> 'b) -> 'a -> 'c

K संयोजक:

fun(f)(u)->u प्रकार के साथ 'a -> 'b -> 'b

मैं संयोजक:

fun(f)->f प्रकार के साथ 'a -> 'a

जैसा कि ais523 ने नोट किया है कि यह केवल SKI को एनकोड करने के लिए अपर्याप्त है। यहां टाइप सिस्टम में हेरफेर करने के लिए पॉलीमॉर्फिक वेरिएंट का उपयोग करते हुए जेड के लिए एन्कोडिंग है। इसके साथ मेरा सबसेट पूरा होना चाहिए।

Z संयोजक:

fun(f)->(fun(`X(x))->(x)(`X(x)))(`X(fun(`X(x))y->f(x(`X(x)))y))

प्रकार के साथ (('a -> 'b) -> 'a -> 'b) -> 'a -> 'b


2
बस टाइप किए गए SKI कॉम्बीनेटर कैलकुलस ट्यूरिंग-पूर्ण नहीं है; उसके लिए आपको एक लाइप्ड लैम्ब्डा कैलकुलस की आवश्यकता है। दुर्भाग्य से, जैसा कि आपके प्रदर्शनों का उल्लेख है, OCaml डिफ़ॉल्ट रूप से कोड पर एक टाइप की गई व्याख्या डालता है।

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

जेड कॉम्बिनेटर क्या है?
कैलक्यूलेटरफैनलाइन

@CalculatorFeline यह वाई-कॉम्बिनेटर का एक सख्त संस्करण है। यह OCaml में आवश्यक है क्योंकि OCaml आलसी नहीं है। यहाँ विकिपीडिया पृष्ठ का लिंक दिया गया है: en.wikipedia.org/wiki/…
डेविन लेहमैचर

8

स्टैक-आधारित समसामयिक भाषाएँ, 4 वर्ण

लादना

():^

GolfScript

{}.~

CJam

{}_~

GS2

  • बैकस्पेस, टैब, @स्पेस (मुझे पता था कि GS2 ने unprintables का बहुत उपयोग किया है, लेकिन यह हास्यास्पद है ...)

dc (@seshoumara द्वारा सुझाया गया)

[]dx

केवल के उपयोग के साथ ():^अंडरलोडिंग को ट्यूरिंग-पूर्ण साबित कर दिया गया है (एसोलंग के निवासी गणितज्ञ अर्जन के लिए धन्यवाद)। प्रमाण यहाँ समझाने के लिए बहुत लंबा है, लेकिन अगर आप रुचि रखते हैं, तो आप इसके बारे में यहाँ पढ़ सकते हैं ।

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


मैं समझता हूं कि आप उन लोगों के साथ स्टैक ऑपरेशन कर सकते हैं, लेकिन गणितीय गणना करने के लिए आपको उस स्टैक को आबाद करने के लिए कम से कम संख्याओं की आवश्यकता नहीं है? या जो 4 वर्णों में से एक का उपयोग करते हुए एकात्मक में किया जाता है?
शीशमारा

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

मैं खुद को डीसी में एक जवाब प्रस्तुत करने की सोच रहा था, एक स्टैक आधारित भाषा भी, लेकिन 4. से अधिक वर्णों को शामिल करने वाली एक अन्य विधि का उपयोग करते हुए डीसी का कोई संघनन ऑपरेटर नहीं है, लेकिन इसमें आपके द्वारा उल्लेखित समतुल्य हैं: [] डी एक्स। क्या डीसी आपकी सूची में फिट हो सकता है?
शीशमारा

@ शेशमौरा: हां, ऐसा लगता है कि इसमें सभी प्रकार की कार्यक्षमता की आवश्यकता है। मैंने इसे जोड़ा है और आपको श्रेय दिया है।

शायद आप FlogScript
mbomb007

7

व्हॉट्सएप, 3 चरस

STL

Sस्थान है, Tटैब है, और Lन्यूलाइन है।


क्या यह पूरी भाषा है, या यह एक सबसेट है? ट्यूरिंग पूर्णता का प्रमाण कहाँ है?
ब्रायन मिंटन

2
@BrianMinton यह पूर्ण भाषा है, esolang विकि बहुत उस पर प्रकाश है esolangs.org/wiki/Whitespace लेकिन afaik, यह ट्यूरिंग पूरा हो गया है
क्रंचर

7

रैकेट (योजना), 4 वर्ण

(λ)

केवल λ, कोष्ठक, और स्थान का उपयोग करके, हम सीधे योजना के सबसेट लैमबेटस सबसेट में कार्यक्रम कर सकते हैं। हम सभी पहचानकर्ताओं के लिए λ चरित्र का पुन: उपयोग करते हैं, ताकि वे एक साथ बड़ी संख्या में अद्वितीय पहचानकर्ता प्रदान कर सकें।

एक उदाहरण के रूप में, यहां क्लासिक ओमेगा कॉम्बिनेटर है, जो हमेशा के लिए बंद हो जाता है।

((λ (λλ) (λλ λλ)) (λ (λλ) (λλ λλ)))

6

पायथन 3, 9 अक्षर

exc('%1+)

एक बुनियादी स्पष्टीकरण के लिए मेरा पायथन 2 उत्तर देखें । यह उत्तर उसी पर बनता है।

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

exec('%c'%stuff)

लेकिन हम +इसके बजाय का उपयोग करके प्रोग्राम की लंबाई को छोटा करते हैं -, और फिर हम इसके बजाय का ~उपयोग करके निकाल सकते 1हैं 0। हम तब जोड़ सकते हैं 1, 11और 111आवश्यक ASCII मान प्राप्त करने के लिए।

कार्यक्रम print()अपने सबसे कम समय में निम्न हो जाता है:

exec('%c%%c%%%%c%%%%%%%%c%%%%%%%%%%%%%%%%c%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%c%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%c'%(111+1)%(111+1+1+1)%(11+11+11+11+11+11+11+11+11+1+1+1+1+1+1)%(11+11+11+11+11+11+11+11+11+11)%(111+1+1+1+1+1)%'('%')')

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

आप खुद सोच रहे होंगे कि बिना NUL बाइट के कोई कैसे बनाता है 0? डर नहीं, युवा टिड्डा! क्योंकि हमारे पास %गणित के साथ-साथ शून्य का उपयोग करने की क्षमता है 1%1


आप अपने कार्यक्रम में कभी NUL बाइट क्यों चाहते हैं?
निएडजेककोब

@NieDzejkob इस साइट पर, "क्यों" हमेशा "क्योंकि हम कर सकते हैं" का उत्तर है। इस मामले में, हालांकि, यह पायथन का पूर्ण कार्यान्वयन नहीं होगा यदि आप ऐसा नहीं कर सकते हैं, भले ही यह सिर्फ एक त्रुटि देता है।
mbomb007

ट्यूरिंग पूर्णता के लिए आपको एनयूएल बाइट की आवश्यकता नहीं होगी; एक BF दुभाषिया को एक के बिना लिखा जा सकता है
MilkyWay90

@ MilkyWay90 सच है, लेकिन अगर आप कर सकते हैं तो इसका हिसाब क्यों नहीं?
mbomb007 20

6

PHP 7, 6 अक्षर

'().;^

विचार यह है कि निम्नलिखित निर्माण का उपयोग करके मनमाना कोड निष्पादित करना संभव है:

('create_function')('','<code>')();

eval यहां काम नहीं करेगा, क्योंकि यह एक भाषा निर्माण है और इसे चर कार्यों का उपयोग करके नहीं बुलाया जा सकता है।

create_function और कोड उपलब्ध वर्णों के बिटवाइज़ XOR के संघटन के रूप में लिखा जा सकता है:

(<char1_1>^<char1_2>^...).(<char2_1>^<char2_2>^...)...

का उपयोग ().;^करने के लिए <charX_Y>, हम प्राप्त कर सकते हैं

()./:;<=JKLMXY^_bcdepqvw

और कुछ अप्रत्याशित अक्षर। यह पर्याप्त नहीं है, लेकिन अब हम 'eXp'()कुछ संख्यात्मक वर्ण भी कॉल और प्राप्त कर सकते हैं:

''.'eXp'('eXp'('')) -> 1
''.'eXp'('eXp'('eXp'(''))) -> 2.718281828459
''.'eXp'('eXp'('eXp'('eXp'('eXp'(''))))) -> 3814279.1047602

यह हमें देता है 1, 2और 3अन्य पात्रों को XOR द्वारा नजरअंदाज कर दिया जाएगा, यदि दूसरा तार एक वर्ण लंबा है)। से ().;^123अब हम सब ASCII चारसेट उत्पन्न कर सकते हैं।

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


5

पायके, 5 अक्षर

0h.CE

यह एक असीम रूप से बड़ी संख्या में उत्पादन करने में सक्षम है, इसे एक स्ट्रिंग में बदल दिया जाता है और फिर इसे Pyke कोड के रूप में मूल्यांकन किया जाता है।

कोड की व्याख्या:

0- स्टैक में जोड़ें। यह एक नंबर शुरू करने के लिए आवश्यक है

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

.C- निम्नलिखित एल्गोरिथ्म का उपयोग करके एक संख्या को स्ट्रिंग में बदलें: ( जीथब लिंक )

def to_string(num):
    string = ""
    while num > 256:
        num, new = divmod(num, 256)
        string = chr(new) + string
    string = chr(num) + string
    return string

इस बिंदु तक, हम मनमाने ढंग से मूल्यों के साथ पियर्स में मनमाने ढंग से तार और प्राकृतिक संख्या बना सकते हैं। रेगेक्स के अनुरूप फॉर्म में नंबर बनाए जा सकते हैं 0(h)*और स्ट्रिंग्स के साथ बनाया जा सकता है 0(h)*.C। तार और पूर्णांक का एक मनमाना मिश्रण बनाने के लिए उन्हें एक-दूसरे के साथ जोड़ा जा सकता है।

E- Pyke कोड के रूप में एक स्ट्रिंग का मूल्यांकन करें। यह उसी वातावरण का उपयोग करता है, जैसा कि पहले से चल रहा Pyke कोड इनपुट जैसी चीजों को साझा करेगा।

इस बात का प्रमाण दिया गया कि पाइक ट्यूरिंग कम्प्लीट है।

किसी भाषा को दिखाने का सबसे सरल तरीका है ट्यूरिंग * ब्रेनफ * ck को लागू करके। यह शायद पेक में कई अन्य भाषाओं की तुलना में बहुत कठिन है क्योंकि यह सूची और शब्दकोश संचालन बहुत ही गैर-मौजूद हैं क्योंकि पाइके को क्षेत्र में उनकी आवश्यकता की कमी के कारण बनाया गया है:

सबसे पहले हम ब्रेनफ * ck के लिए एक दुभाषिया बनाते हैं और एक नंबर बनाने के लिए ऊपर दिए गए हमारे एल्गोरिदम का उपयोग करते हुए इसे एनकोड करते हैं और फिर उस नंबर को व्यक्त करते हैं 0और h। हम फिर उसी तरह से चलने वाले कोड युक्त स्ट्रिंग बनाते हैं। यदि हम इसे उस पर छोड़ देते, तो हमारे पास जैसा होता, वैसा ही होता

string containing brainf*ck code
string containing brainf*ck interpreter

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

अब मज़ेदार हिस्से के लिए: दिमागी * ck दुभाषिया के साथ 216 बाइट्स!

Q~B"><ht.,".:=B;Z]1=L;W~Bo@D=c"ht"{I~c~LZ@EZ]1~LR3:=L)~c\,qIz.oZ]1~LR3:=L)~c\.qI~LZ@.CpK)~c"<>"{I~c"<>""th".:ZE=ZZ1_qI0=Z~L0"":0]10:=L)Z~LlqI~L~Ll"":1_]10:=L))~c\[qI~LZ@0qI\]~B~o>@~o+h=o))~c\]qI~o\[~B~o<_@-t=o)~o~BlN

यहाँ यह कोशिश करो!

यदि आप कोड को अर्ध-पूर्ण लेकिन संपादन योग्य रूप में आज़माना चाहते हैं , तो इसे यहाँ आज़माएँ!

स्ट्रिंग से संख्या में परिवर्तित करने के लिए, आप निम्न पायथन कोड का उपयोग कर सकते हैं:

def conv(string, t=0):
    t *= 256
    t += ord(string[0])
    if len(string) != 1:
        return conv(string[1:], t)
    return t

(लगभग) अंतिम समाधान यहाँ कोशिश की जा सकती है!

ब्रेनफ की व्याख्या * ck दुभाषिया

पहले कार्यक्रम को भागों में अलग करते हैं:

  • आरंभीकरण:

Q~B"><ht.,".:=B;Z]1=L; - The initialisation part
Q~B"><ht.,".:          - input.replace("><+-.,[]", "><ht.,")
                       - replace the characters in brainf*ck with some modified ones. 
                       - this means we can `eval` the add and subtract bits easily.
             =B;       - set `B` to this.
                       - The `B` variable contains the instructions
                Z]1=L; - set `L` to [0]
                       - `L` contains the stack, initialised with 0
  • मुख्य लूप:

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

W~Bo@D=c !code! ~o~BlN - The main loop
W                      - do
 ~Bo@D=c               -  c=B[o++]
                       -  the c variable is used to store the current character.
                ~o~BlN - while
                ~o     -   o 
                     N -  ^ != V 
                  ~Bl  -   len(B)
                       -  this stops the program running once it's finished.
  • अनुदेश
    • बढ़ते क्रम में / घटते क्रम में:+-

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

"ht"{I~c~LZ@EZ]1~LR3:=L) - The bit that does incrementing and decrementing
"ht"{I                 ) - if c in "ht"
        ~LZ@             -  L[Z]
                         -  `Z` contains the current stack pointer
      ~c    E            -  eval current character with ^ as an argument
                         -  returns the contents of `Z` either incremented or decremented
             Z]1~LR3:=L  - L[Z] = ^
  • इनपुट ,:

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

~c\,qIz.oZ]1~LR3:=L) - The code for output 
~c\,qI             ) -  if character == ",":
      z.o            -    ord(input)
         Z]1~LR3:=L  -   L[Z] = ^
  • आउटपुट .:

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

~c\.qI~LZ@.CpK) - The code for input 
~c\.qI        ) - if c == ".":
      ~LZ@      -    L[Z]
          .C    -   chr(^)
            pK  -  print(^)
  • शिफ्ट वाम / अधिकार <>:

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

~c"<>"{I~c"<>""th".:ZE=Z - main part 
~c"<>"{I                 - if "<>" in c:
        ~c"<>""th".:     -  c.replace("<>", "th")
                    ZE=Z -  Z = eval(char, Z)

Z1_qI0=Z~L0"":0]10:=L) - lower bound check
Z1_qI                ) - if Z == -1:
     0=Z               -  Z = 0
        ~L0"":         -  L.insert("", 0)
              0]10:=L  -  L[0] = 0

Z~LlqI~L~Ll"":1_]10:=L) - upper bound check
Z~LlqI                ) - if Z == len(L):
        ~Ll"":          -  L.insert("", len(L))
      ~L      1_]10:=L  -  L[-1] = 0
  • सशर्त [:

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

~c\[qI~LZ@0qI\]~B~o>@~o+h=o)) - Code for `[`
~c\[qI                      ) - if c == "[":
      ~LZ@0qI              )  -  if L[Z] == 0:
               ~B~o>          -     B[o:]
             \]     @         -    ^.find("]")
                     ~o+h=o   -   o = o + ^ + 1

- तथा ] :

उन्होंने कहा कि इस तरह की घटनाओं को रोकने के लिए सरकार की ओर से कोई ठोस कदम नहीं उठाया गया है।

~c\]qI~o\[~B~o<_@-t=o) - Code for `]`
~c\]qI               ) - if c == "]":
          ~B~o<_       -    reversed(B[:o])
        \[      @      -   ^.find("[")
      ~o         -t=o  -  o = o - ^ -1

5

ढेर, 5 चरखा

{!n:}

यह आश्चर्यजनक रूप से कम है। यदि स्टैक्ड प्रत्येक SKI संयोजनों को लागू कर सकता है, तो यह ट्यूरिंग कम्प्लीट है। संक्षिप्त:

  • I कॉम्बिनेटर - पहचान समारोह। x -> x
  • K कॉम्बिनेटर - निरंतर कार्य। x -> y -> x
  • S कॉम्बिनेटर - प्रतिस्थापन समारोह। (x, y, z) -> x(z)(y(z))

मैं संयोजनकर्ता: {!n}

अब, खड़ी बारीकियों के लिए। {! ... }एक n-lambda है। यह एक असमान फ़ंक्शन है जिसका तर्क अंतर्निहित है n। फिर, अंतिम अभिव्यक्ति फ़ंक्शन से वापस आ जाती है। इस प्रकार, {!n}एक फ़ंक्शन है जो एक तर्क लेता है nऔर उपज देता हैn

के कॉम्बिनेटर: {!{:n}}

अब, {:...}एक फ़ंक्शन है जो कोई तर्क नहीं लेता है, और रिटर्न करता है ...। इसे हमारे n-lambda गठन के साथ मिलाकर, हमें प्राप्त होता है (स्पष्टता के लिए व्हॉट्सएप जोड़ना):

{! { : n } }
{!         }   n-lambda. arguments: (n)
   { : n }     lambda.   arguments: ()
       n       yields n.

एस संयोजक: {n!nn!nnn:nnn{!n}!nn!nnn{!n}!n!!}

ठीक है, यह थोड़ा अधिक जटिल लगता है। तो, एक मेमना तर्क देता है, गैर-पहचानकर्ता पात्रों द्वारा अलग किया जाता है। इस प्रकार, शीर्ष लेख में लैम्बडा इसके बराबर है:

{n nn nnn:nnn{!n}!nn!nnn{!n}!n!!}

यह एक लैम्ब्डा कि तीन तर्क लेता है, है n, nnऔर nnn। के साथ इन की जगह करते हैं x, yऔर zस्पष्टता के लिए:

{x y z:z{!n}!y!z{!n}!x!!}

दो {!n}!व्हाट्सएप से बचने के लिए सिर्फ पहचान समारोह है, !जिसका अर्थ है "निष्पादित"। तो, फिर से, कम करना:

{x y z:z y!z x!!}

एक स्पष्टीकरण के साथ:

{x y z:z y!z x!!}
{x y z:         }  three arguments
       z y!        apply `y` to `z` -- `y(z)`
           z x!    apply `x` to `z` -- `x(z)`
               !   apply `x(z)` to `y(z)` -- `x(z)(y(z))`

और इसलिए, यह एस कॉम्बिनेटर है।


{n nn nnn:nnn{!n}!nn!nnn{!n}!n!!}रिक्त स्थान शामिल हैं।
कैलक्यूलेटरफल

@CalculatorFeline क्या आपने उससे पहले वाक्य पढ़ा था? ठीक है, यह थोड़ा अधिक जटिल लगता है। तो, एक मेमना तर्क देता है, गैर-पहचानकर्ता पात्रों द्वारा अलग किया जाता है। इस प्रकार, हेडर में लैम्बडा के बराबर है:
कॉनर ओ'ब्रायन

ओह। (स्वयं पर ध्यान दें: एक मूर्ख होना बंद करें।)
कैलक्यूलेटरफल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.