🙌🏽 🙌🏿 👩🏽‍💼 बहुविकल्पी जनक 🙌🏽 🚉 🌇

हैबर्स क्वीन के महीने पर, इसलिए मैं अपने विकास को साझा करना चाहता हूं, जो मैंने चार साल पहले किया था।

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

चूंकि हम कार्यक्रम ग्रंथों और उनके निष्पादन के परिणामों के साथ काम कर रहे हैं, इसलिए इस मामले को लाइनों के कार्यों के रूप में देखना स्वाभाविक होगा।

कार्यों

हमारे पास क्या विशेषताएं हैं?
सबसे पहले, यह एक दुभाषिया है : यह कार्यक्रम का पाठ लेता है, मानक आउटपुट से पाठ को संकलित करता है, चलाता है, और वापस करता है।
हम इस फ़ंक्शन को बस कहते हैं: RUN ।
चूंकि हम एक भाषा तक सीमित नहीं होंगे, वास्तव में, हमारे पास एक पूरा परिवार है: Runpython, RUNc, RUNbrainfuck ...
यह स्पष्ट है कि इन कार्यों को अलग-अलग तरीकों से लागू किया जाता है, लेकिन वास्तव में कैसे - यह हमें चिंता नहीं करनी चाहिए। आखिरकार, हम भाषा के अपने व्याख्याकार को नहीं लिखते हैं, और इससे भी अधिक, उसी भाषा में।
सामान्य तौर पर, मुख्य कार्यान्वयन अब हमारे सिर में होगा, क्योंकि हम स्ट्रिंग समीकरणों को हल करेंगे।

दूसरे, कार्यों का एक महत्वपूर्ण परिवार डेकोरेटर और लेखक हैं । डेकोरेटर एक मनमाना स्ट्रिंग लेता है और इसमें विशेष पात्रों को बदलता है, और फिर लेखक स्ट्रिंग को उद्धरण चिह्नों से घेरता है।
L x = qopen + D x + qclose
डेकोरेटर्स की एक महत्वपूर्ण संपत्ति स्ट्रिंग्स के जोड़ (संयोजन) के संचालन के लिए संवेदनशीलता है: ई (एक्स + वाई) = एक्स + आई।

वैसे, हम तुरंत सहमत होंगे: रिकॉर्ड की संरचना के लिए, फ़ंक्शन बड़े अक्षरों में होंगे, छोटे अक्षरों में तार, एफएक्स - फ़ंक्शन को एफ से एक्स पर लागू करना, एफजीएक्स - एफ को जीएक्स पर लागू करना, या, एक ही है, रचना एफजी से एक्स पर लागू करना।

Quine

यदि आप C में सबसे छोटी रानी को देखते हैं,

char*f="char*f=%c%s%c;main(){printf(f,34,f,34,10);}%c";main(){printf(f,34,f,34,10);}

तब हम एक विशेषता पैटर्न देखेंगे। यहां, कार्यक्रम के दो टुकड़े दो बार दोहराए जाते हैं - एक बार शीर्ष-स्तरीय पाठ के रूप में, दूसरी बार स्ट्रिंग शाब्दिक के रूप में।

और इसे नीचे लिखें: quine = a + b + Ea + c + Ee + d + e

ठीक उसी तरह, जैसे हम अजगर में क्वीन बना सकते हैं:

 s1,s2 = 's1,s2 = ', "\nprint s1+repr(s1)+', '+repr(s2)+s2" print s1+repr(s1)+', '+repr(s2)+s2

या, थोड़ा और स्पष्ट रूप से और क्रिया:

 # this is quine s1 = '# this is quine' s2 = 'print s1\nprint "s1="+repr(s1)\nprint "s2="+repr(s2)\nprint s2' print s1 print "s1="+repr(s1) print "s2="+repr(s2) print s2

सबस्ट्रिंग ए और ई जानकारीपूर्ण हैं, बड़े ग्रंथ जो प्रोग्रामेटिक रूप से उत्पन्न करने के लिए अवास्तविक हैं; सबस्ट्रिंग बी, सी, डी - गोंद, आमतौर पर उद्धरण चिह्नों, गाड़ी स्थानांतरण, आदि से मिलकर।

स्पष्टता की बात करना। कार्यक्रम के पाठ को आसानी से एक अखंड रेखा के रूप में नहीं, बल्कि रेखाओं की सूची के रूप में माना जा सकता है। एक अन्य लेख में, मैं निश्चित रूप से इस पर लौटूंगा, और सूचियों के साथ काम करने के तरीके के एक जोड़े को दिखाऊंगा।
इस बीच, वापस रानी के पास।
RUN फ़ंक्शन को क्वीन के लिए परिभाषित किया गया है: RUN quine = quine ।
यानी, क्वीन RUN फ़ंक्शन का एक निश्चित बिंदु है।
आइए संक्षेप में क्वीन को संक्षिप्त करते हैं। क्या होगा अगर हम मनमाने तरीके से मनमाने तार को आउटपुट करना सीखें?

 Q(F,f,g,h,i,j) = a + b + Ef + c + Ej + d + e --  a,b,c,d,e -  () F  g,h,i. RUN Q(F,f,g,h,i,j) = f + g + Ff + h + Fj + i + j

एक ही अजगर पर:

 # this is Q def F(s) : '''     F   ''' s1 = 'Ef' s2 = 'Ej' print s1 + 'Eg' + F(s1) + 'Eh' + F(s2) + 'Ei' + s2 #  Ef, Eg, Eh, Ei, Ej —  -

क्वान प्रतिस्थापन पदार्थ का हल है: RUN Q(F,f,g,h,i,j) = Q(F,f,g,h,i,j)

 RUN Q(F,f,g,h,i,j) = f + b + Ff + c + Fj + d + e Q(F,f,g,h,i,j) = a + b + Ff + c + Ej + d + e

Whence F = E, अर्थात सजावट की सॉफ्टवेयर विधि भाषा के नियमों के अनुसार सजावट के साथ मेल खाती है; पाठ के टुकड़े - यह स्पष्ट है कि क्या साथ मेल खाता है।

एक और विषयांतर: यहां तक कि एक ही भाषा के भीतर, सज्जाकार बहुत, बहुत अलग हो सकते हैं। हम उदाहरण के लिए, संख्याओं के एक समूह के रूप में तारों का प्रतिनिधित्व कर सकते हैं।
फिर "लाइन" का आउटपुट 104, 97, 98, 114 प्रिंट '' .join (मैप (chr), xs) है, और सजाए गए फॉर्म में आउटपुट प्रिंट है ',' जॉइन (मैप (str), xs)।

कृपया ध्यान दें: RUN और Q फ़ंक्शंस स्ट्रिंग्स के ऊपर परिभाषित किए गए हैं (Q आमतौर पर स्ट्रिंग्स और एक फंक्शन पर परिभाषित एक उच्च-क्रम फ़ंक्शन है), लेकिन उनका कार्यान्वयन लक्ष्य प्रोग्रामिंग भाषा के बाहर होता है जिसमें हम क्वीन लिखते हैं। जबकि फ़ंक्शन E को लक्ष्य भाषा में पाठ के रूप में लागू किया जाना चाहिए!

प्रिंटर

अब चलो एक और, बहुत ही सरल कार्यक्रम देखें। यह कार्यक्रम निर्दिष्ट पाठ को प्रिंट करता है।

 printer = p + Sq + r RUN printer = q

जहां एस सजाया पाठ भंडारण का कुछ तरीका है।

चूंकि हम पूरी तरह से मनमाने पाठ के लिए एक प्रिंटर लिख सकते हैं, हम एक फंक्शन करेंगे:

 P(q) = p + Sq + r

बेशक, अपरिवर्तनीय: RUN P(q) = q
यही है, प्रिंटर दुभाषिया के विपरीत एक फ़ंक्शन है!

सी में:

 #include <stdio.h> int main() { printf("%s", "hello\nhabr"); return 0; }

अजगर पर:

 print """ hello RSDN """

यही है, यहाँ फ़ंक्शन S अच्छे पुराने ई के साथ मेल खाता है (अजगर पर, यह और भी सरल है, आपको लाइन फीड से बचना नहीं होगा)।
और यहाँ - मेल नहीं खाता:

 #include <stdio.h> int main() { putchar(114);putchar(115);putchar(100);putchar(110); return 0; }

प्रिंटर P, क्वीन क्यू के साथ अनुकूलता से तुलना करता है कि इसके तत्व, p और r, फ़ंक्शन के मापदंडों से स्वतंत्र हैं।

मेटा- प्रिंटर को प्रिंटर से बनाना आसान है: एक प्रोग्राम जो एक प्रोग्राम प्रिंट करता है जो टेक्स्ट प्रिंट करता है।

 Pmeta (q) = PPq = P(p + Sq + r) = p + S(p + Sq + r) + r = p + Sp + SSq + Sr + r pmeta = p + Sp Smeta = SS rmeta = Sr + r RUN (RUN( Pmeta(q) )) = q

कोई हमें बहुभाषी प्रिंटर बनाने से नहीं रोक रहा है:

 Pbilingua(q) = P'P"q = P'(p" + S"q + r") = p' + S'p" + S'S"q + S'r" + r' RUN"(RUN'(Pbilingua(q))) = RUN"(RUN'(P'P"(q))) = RUN"(P"(q)) = q

और सामान्य तौर पर, आप कितनी भी भाषाओं का उपयोग कर सकते हैं ( मल्टी-प्रिंटर ):

 Pmulti(q) = pmulti + Smultiq + rmulti pmulti = p1 + S1p2 + S1S2p3 + S1S2S3p4 Smulti = S1S2S3S4 rmulti = S1S2S3r4 + S1S2r3 + S1r2 + r1

हम सभी को यह जानने की जरूरत है कि सज्जाकारों के कार्यों की रचना कैसे करें। (इस बारे में - नीचे)।

और एक और प्रिंटर, पूर्णता के लिए: यह एक अशक्त प्रिंटर P0 (पाठ) = पाठ है

 p0 = "" r0 = "" S0 = id

पिंग पोंग

खैर, अब प्रिंटर (या मल्टी-प्रिंटर) और क्वीन को पार करते हैं।
यहां समीकरण का हल पहले से ही आवश्यक है।
चलो इन कार्यक्रमों को पिंग और पोंग कहते हैं:

 RUN ping = pong RUN pong = ping

और पिंग प्रिंटर P (पोंग) हो, और पोंग कुछ अधिक जटिल हो। यदि यह पी (पिंग) था, तो हम एक असीम रूप से विस्तारित स्ट्रिंग के साथ समाप्त हो जाएंगे, और हम अंतिम समाधान चाहते हैं।
तो पोंग = क्यू (एफ, एफ, जी, एच, आई, जे)।
स्थानापन्न:

 ping = P pong = p + S pong + r = p + S(a + b + Ef + c + Ej + d + e) + r = p + Sa + Sb + SEf + Sc + SEj + Sd + Se + r = (p + Sa + Sb) + SEf + Sc + SEj + (Sd + Se + r) ping = RUN pong = f + g + Ff + h + Fj + i + j

ऐसा क्यों है, उदाहरण के लिए f = p+Sa+Sb , और g=Sa+Sb नहीं?
तथ्य यह है कि च और जे को विशेष रूप से पुनरावृत्ति के लिए डिज़ाइन किया गया है: हम आसानी से उन में पोंग स्रोत कोड (सबस्ट्रिंग ए, बी, डी, ई) के टुकड़े का उल्लेख कर सकते हैं, जबकि जी, एच, आई में पुनरावृत्ति अवांछनीय है।

तो हम मिल गए
pong = a+b + E(p+Sa+Sb) + c + E(Sd+Se+r) + d+e

और कहीं एक या ई के आंतों में फ़ंक्शन F = SE और स्ट्रिंग ESc छिपा रहे हैं।
नोट: यदि ई में ईएससी है, तो पुनरावृत्ति नहीं होती है क्योंकि सी ई से स्वतंत्र है।

आइए अब हम इन "आंतों में छिपने" से छुटकारा पाएं। एक और फंक्शन लें।
चलो

 pong = R(F,x,y,z) = a + Ex + b + Ez + c + Ey + d RUN R(F,x,y,z) = x + Fx + y + Fz + z P pong = p+Sa + SEx + Sb + SEz + Sc+SEy+Sd+r RUN pong = x + Fx + y + Fz + z

तो हमें मिला:

 F = SE x = p+Sa y = Sb z = Sc+SEy+Sd+r = Sc + SESb + Sd + r

यदि आप पोंग को थोड़ा अलग तरीके से परिभाषित करते हैं,

 pong = R(F,x,y,z) = a + Ex + b + Ey + b + Ez + c RUN R(F,x,y,z) = x + Fx + y + Fy + y + Fz + z

यही है, अगर हमें स्ट्रिंग स्थिरांक की एक सूची मिली, तो हम दोहरी सजावट से छुटकारा पा लेंगे:

 P pong = p+Sa + SEx + Sb + SEy + Sb + SEz + Sc+r RUN pong = x + Fx + y + Fy + y + Fz + z

इस प्रकार, यदि हमारे पास P = {S, p,r} और R = {E,a,b,c} लिए रिक्त स्थान हैं, तो हम तुरंत उन्हें पिंग-पोंग में बदल देंगे। और यह मत भूलो कि पी एक मल्टी-प्रिंटर हो सकता है। फिर पिंग-पोंग n + 1 की अवधि के साथ दोलन करेगा, जहां n बहु-प्रिंटर की बहुलता है। और यदि P एक अशक्त प्रिंटर है, तो पिंग-पोंग 1 की अवधि के साथ दोलन करेगा और (जिसने सोचा होगा?) एक क्वीन बन जाता है।

आखिरी चीज जो हमारे लिए बनी हुई है वह है कंपोजिशन एसई।
औपचारिक रूप से, कार्य ऐसा लगता है।
दिया गया: पोंग प्रोग्रामिंग भाषा; सज्जाकार ई और एस, इस भाषा के ई मूल निवासी के साथ, और एस कोई भी।
खोजें: पौंग सबरूटीन पाठ जो एसई डेकोरेटर को लागू करता है।
और उसी समय, विकास पर्यावरण की भाषा में सज्जाकार ई और एसई लागू करें। आखिरकार, हम बहुस्तरीय की पीढ़ी को स्वचालित करना चाहते हैं?

ऐसा करने के लिए, आइए देखें कि सज्जाकार फिर से कैसे व्यवस्थित होते हैं।
डेकोरेटर इसके अतिरिक्त वितरण योग्य है: F (a + b) = Fa + Fb।
यदि हम स्ट्रिंग को प्राथमिक भागों में तोड़ते हैं - एकल-वर्ण स्ट्रिंग्स, हम प्राप्त करते हैं
F(abcd…) = Fa + Fb + Fc + Fd + …
सज्जाकार सहयोगी हैं:
FG(abcd…) = FGa + FGb + FGc + FGd + …

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

इस प्रकार, कार्य योजना इस प्रकार थी:
दिए गए:

अज्ञात भाषाओं में प्रिंटर {Sk,pk,rk} (हम सभी की जरूरत है Sk कार्यों का सिर्फ एक टेबल कार्यान्वयन है);
पोंग टेम्पलेट {E,a(F),b,c(F)} , जहां एक या डी एक मनमाना कोड टेबल एफ के लिए एक स्थान आरक्षित करता है (इसलिए ए और सी तार नहीं हैं और तार पर कार्य नहीं करते हैं, लेकिन उच्च-क्रम के कार्य)।

हम कार्य करते हैं:

हम बहु-प्रिंटर {S,p,r} , S1S2... गणना S1S2... तालिकाओं से।
हम टेबल F = SE पाते हैं।
यदि वांछित है, तो हम न्यूनतम वर्णमाला पाते हैं - वर्णों का समूह जो p, r, Sa, Sb, Sc, Sd बनाते हैं। यह इसलिए है कि सभी ASCII या, भगवान न करे, यूनिकोड की कोडिंग टेबल को ढेर न करें।
तालिका को c या c में चिपकाएँ।
हम x=(p+Sa), y=(Sb), z=(Sc+r) पाते हैं।
हम एक पोंग बनाते हैं: a+Ex+b+Ey+b+Ey+c ।

वह सब है!

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

 #-*- coding: utf-8 -*- #  - ,     def I(c) : ''' id-,    ''' return c def C(c) : '''      ''' if c=='"' or c=='\\' or ord(c)<32 or ord(c)>126 : return '\\%03o' % ord(c) # ,  ,      #           , #     : \x24bad -    chr(0x24BAD),    $bad else : return c def decor(F,s) : '''     ''' return ''.join(map(F,s)) #       def compose(F,G) : '''   ''' return lambda c : decor(F,G(c)) #  -  (S,p,r) def make_printer(S, tpl, tag = '<-T->') : '''      ( <-T-> ,   ) ''' p,r = tpl.split(tag) return S,p,r nul_printer = (I,'','') def show_printer(prn, t) : '''       t ''' S,p,r = prn return p + decor(S,t) + r def meta_printer(prn1, prn2) : '''   ''' S1,p1,r1 = prn1 S2,p2,r2 = prn2 S = compose(S1,S2) p = p1 + decor(S1,p2) r = decor(S1,r2) + r1 return S,p,r #  - ,      -  (E, am, b, cm) #  am  cm -  decorator -> string def make_quiner(E, M, tpl, tagX = '<-X->', tagF = '<-F->') : '''       <-X->       x,y,z,  <-F-> ,     F  E -  ,  M      ''' a,b,b_,c = tpl.split(tagX) assert b==b_ am = lambda F : a.replace(tagF, M(F)) if tagF in a else a cm = lambda F : c.replace(tagF, M(F)) if tagF in c else c return E,am,b,cm def show_quiner(qnr, F,x,y,z) : '''         a,Ex,b,Ey,b,Ez,c --  x,Fx,y,Fy,y,Fz,z -- ,     (RUN) ''' E,am,b,cm = qnr a,c = am(F), cm(F) ex,ey,ez = decor(E,x), decor(E,y), decor(E,z) return a + ex + b + ey + b + ez + c def show_quiner_printer(qnr,prn) : '''      p+Sa,SEx,Sb,SEy,Sb,SEz,Sc+r --   x , Fx, y , Fy, y , Fz, z --    ''' E,am,b,cm = qnr S,p,r = prn F = compose(S,E) a,c = am(F), cm(F) x = p + decor(S,a) y = decor(S,b) z = decor(S,c) + r ex,ey,ez = decor(E,x), decor(E,y), decor(E,z) return a + ex + b + ey + b + ez + c ############################################################# #     : c_quine_tpl = '''/* C quine */ #include <stdio.h> const char* f[128] = {<-F->}; const char* xyz[3] = {"<-X->", "<-X->", "<-X->"}; void ps(const char* s) { while(*s) putchar(*s++); } void pm(const char* s) { while(*s) ps(f[*s++]); } int main() { ps(xyz[0]); /* x */ pm(xyz[0]); /* Fx */ ps(xyz[1]); /* y */ pm(xyz[1]); /* Fy */ ps(xyz[1]); /* y */ pm(xyz[2]); /* Fz */ ps(xyz[2]); /* z */ return 0; } ''' def c_quine_M(F) : '''   -     ''' codes = [ '"%s"' % decor(C,decor(F,chr(i))) for i in xrange(128) ] return ', '.join(codes) c_quiner = make_quiner(C, c_quine_M, c_quine_tpl) #    ,           py_quine_tpl = '''#!/usr/bin/python import sys m = [ <-F-> ] xyz = [ "<-X->", "<-X->", "<-X->" ] def ps(s) : sys.stdout.write(s) def pm(s) : for c in s : ps(m[ord(c)]) ps(xyz[0]) pm(xyz[0]) ps(xyz[1]) pm(xyz[1]) ps(xyz[1]) pm(xyz[2]) ps(xyz[2]) ''' py_quiner = make_quiner(C, c_quine_M, py_quine_tpl) #     ################### #     : c_printer_tpl = '''#include <stdio.h> int main() { printf("%s", "<-T->"); return 0; } ''' c_printer = make_printer(C, c_printer_tpl) py_printer_tpl = '''import sys sys.stdout.write("<-T->") ''' py_printer = make_printer(C, py_printer_tpl) #################### # !    c_c_printer = meta_printer(c_printer, c_printer) py_py_printer = meta_printer(py_printer, py_printer) #  1  c_quine = show_quiner_printer(c_quiner, nul_printer) py_quine = show_quiner_printer(py_quiner, nul_printer) #  2  c_c_quine = show_quiner_printer(c_quiner, c_printer) py_py_quine = show_quiner_printer(py_quiner, py_printer) #  2  -  c_py_quine = show_quiner_printer(c_quiner, py_printer) py_c_quine = show_quiner_printer(py_quiner, c_printer) #  3  - -   c_c_c_quine = show_quiner_printer(c_quiner, c_c_printer) py_py_py_quine = show_quiner_printer(py_quiner, py_py_printer) c_py_py_quine = show_quiner_printer(c_quiner, py_py_printer) py_c_c_quine = show_quiner_printer(py_quiner, c_c_printer) sys.stdout.write(py_py_py_quine) # ,  , - ...

स्रोत और उसके फल बाल्टी पर पाए जा सकते हैं: bitbucket.org/nickolaym/quines

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

इसे अधिक कॉम्पैक्ट कैसे बनाया जाए (दृष्टिकोण की सार्वभौमिकता और मशीन पीढ़ी के लिए संभावना को संरक्षित करते हुए) - मैं अपने दम पर इस समस्या को हल करने का प्रस्ताव करता हूं।

यदि आप इसे पसंद करते हैं, तो मैं इस विषय पर और लिखूंगा:

कार्यक्रमों की सूची पर कार्य करता है
बुद्धिशीलता की तरह गूंगा भाषाओं की सुविधाएँ

4 साल पहले RSDN पर मेरी चेतना की धारा भी देखें। http://rsdn.ru/forum/etude/3604693

बहुविकल्पी जनक

कार्यों

Quine

प्रिंटर

पिंग पोंग

More articles: