बुरा नहीं एक काफी क्रिया के लिए बुरा टारपीट ...
N
Count i while _%128-9 {
Count x while _/128%2 {
Write 40
_+128
}
Write _%128
_+128-_%128+N
}
Count j while _/256-j {
Write 41
}
(हां, वह सब व्हाट्सएप अनिवार्य है।)
नोट: Acc की इनपुट सीमाओं के कारण !! , कुछ अंत परिसीमन के बिना वर्णों की मनमानी स्ट्रिंग को पढ़ना असंभव है। इसलिए, यह कार्यक्रम इनपुट की उम्मीद करता है (स्टड पर) एक टैब चरित्र के बाद एक स्ट्रिंग के रूप में।
एसीसी !! ?
यह एक ऐसी भाषा है जिसे मैंने बनाया है जो केवल अनुपयोगी प्रतीत होती है । एकमात्र डेटा प्रकार पूर्णांक है, एकमात्र नियंत्रण प्रवाह निर्माण Count x while yलूप है, और डेटा को संग्रहीत करने का एकमात्र तरीका एक एकल संचायक है _। विशेष मूल्य Nऔर Writeकथन का उपयोग करते हुए, इनपुट और आउटपुट एक समय में एक वर्ण किया जाता है । इन सीमाओं के बावजूद, मुझे पूरा यकीन है कि Acc !! ट्यूरिंग-पूर्ण है।
व्याख्या
Acc में बुनियादी रणनीति !! प्रोग्रामिंग मॉड्यूलेटर %और पूर्णांक डिवीजन का उपयोग /संचयकर्ता को वैचारिक रूप से विभाजित करने के लिए करता है, जिससे यह एक ही बार में कई मानों को संग्रहीत कर सकता है। इस कार्यक्रम में, हम तीन ऐसे खंडों का उपयोग करते हैं: निम्नतम-ऑर्डर सात बिट्स ( _%128) इनपुट से एक एएससीआईआई कोड स्टोर करते हैं; अगले बिट ( _/128%2) एक ध्वज मूल्य संग्रहीत करता है; और बचे हुए बिट्स ( _/256) हमें आवश्यक क्लोज़-पार्न्स की संख्या गिनेंगे।
Acc में इनपुट !! विशेष मूल्य से आता है N, जो किसी एकल वर्ण को पढ़ता है और अपने ASCII कोड का मूल्यांकन करता है। किसी भी कथन में केवल एक अभिव्यक्ति होती है जो संचयकर्ता को उस अभिव्यक्ति का परिणाम प्रदान करती है। तो हम पहले अक्षर के कोड को संचायक में संग्रहीत करके शुरू करते हैं।
_%128सबसे हाल ही में पढ़ा गया चरित्र संग्रहीत करेगा। तो पहला लूप चलता है जबकि _%128-9नॉनजरो होता है - अर्थात, जब तक कि वर्तमान वर्ण एक टैब नहीं है।
लूप के अंदर, हम ( तब तक प्रिंट करना चाहते हैं जब तक कि हम पहले पुनरावृत्ति पर न हों। चूंकि Acc !! कोई बयान नहीं है, तो हमें सशर्त के लिए लूप का उपयोग करना होगा। हम संचायक के 128 बिट का उपयोग _/128%2ध्वज मूल्य के रूप में करते हैं। पहले पास पर, संचायक में केवल एक चीज ASCII मान <128 है, इसलिए ध्वज 0 है और लूप छोड़ दिया गया है। प्रत्येक बाद के पास पर, हम यह सुनिश्चित करेंगे कि ध्वज 1 है।
Count xलूप के अंदर (जब भी झंडा 1 होता है), हम एक ओपन पेरेन (ASCII 40) लिखते हैं और संचायक में 128 जोड़ते हैं, जिससे ध्वज को 0 पर सेट किया जाता है और लूप से बाहर निकलता है। यह उस मूल्य को बढ़ाने के लिए भी होता है _/256, जिसका हम आउटपुट के रूप में क्लोज-पैरेंस के हमारे टैली के रूप में उपयोग करेंगे।
झंडे के मूल्य के बावजूद, हम सबसे हालिया इनपुट चार लिखते हैं, जो कि बस है _%128।
अगला असाइनमेंट ( _+128-_%128+N) दो काम करता है। सबसे पहले, 128 जोड़कर, यह अगली बार लूप के माध्यम से झंडा सेट करता है। दूसरा, यह _%128स्लॉट को शून्य करता है , दूसरे वर्ण को पढ़ता है, और इसे वहां संग्रहीत करता है। फिर हम लूप करते हैं।
जब Count iलूप बाहर निकलता है, तो हमने सिर्फ एक टैब वर्ण पढ़ा है, और संचायक मान इस तरह टूट जाता है:
_%128: 9(टैब वर्ण)_/128%2: 1(झंडा)_/256: पढ़ने वाले पात्रों की संख्या, घटा 1
(माइनस 1 क्योंकि हम केवल मुख्य लूप के माध्यम से पहले पास के दौरान एक बार संचायक में 128 जोड़ते हैं।) अब हमें जो कुछ भी चाहिए वह क्लोज-परेंस हैं। प्रत्येक बार एक पास-परन (ASCII ) लिखते हुए Count j while _/256-jलूप्स । देखा!_/25641