बहुभाषी रजाई

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

यहाँ अजगर में कोड है जो ब्रेनफैक में कोड उत्पन्न करता है, जो कि अम्बाम्बिया में कोड उत्पन्न करता है, जो कि अजगर में मूल कोड उत्पन्न करता है:

data = 'def brainfuck(st): return "".join(["+"*ord(c)+".>" for c in st])\ndef unlambda(st): return "`r"+"`"*len(st)+"".join(["."+e for e in st])+"i"\nprint brainfuck(unlambda(\'data = %s\'%`data`+chr(10)+data))' def brainfuck(st): return "".join(["+"*ord(c)+".>" for c in st]) def unlambda(st): return "`r"+"`"*len(st)+"".join(["."+e for e in st])+"i" print brainfuck(unlambda('data = %s'%`data`+chr(10)+data)) 

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

 >>> data = 'def brainfuck(st): return "".join(["+"*ord(c)+".>" for c in st])\ndef unlambda(st): return "`r"+"`"*len(st)+"".join(["."+e for e in st])+"i"\nprint brainfuck(unlambda(\'data = %s\'%`data`+chr(10)+data))' >>> print data def brainfuck(st): return "".join(["+"*ord(c)+".>" for c in st]) def unlambda(st): return "`r"+"`"*len(st)+"".join(["."+e for e in st])+"i" print brainfuck(unlambda('data = %s'%`data`+chr(10)+data)) 

तदनुसार, संपूर्ण कार्यक्रम पाठ को निम्नलिखित पंक्ति द्वारा दर्शाया जा सकता है:

 'data = %s'%`data`+chr(10)+data 

अनलम्बा फंक्शन टेक्स्ट को रिसीव करता है और अनलम्बा को एक प्रोग्राम देता है जो इसे प्रिंट करता है।
ब्रेनफक फ़ंक्शन ब्रेनफक के लिए समान है।

अच्छी तरह से और तदनुसार

 brainfuck(unlambda('data = %s'%`data`+chr(10)+data)) 

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

अद्यतन।

मैंने टिप्पणियों में चर्चा को देखा और महसूस किया कि मुझे बेहतर व्याख्या करने की आवश्यकता है।
एक क्विलिन जैसी डिज़ाइन (इसके बाद, हम केवल उन भाषाओं के बारे में बात करेंगे जहाँ आप डेटा और कोड अलग कर सकते हैं) को दो भागों में विभाजित किया जा सकता है:
1) डेटा खंड (एक महत्वपूर्ण बिंदु, यह भाग तब तक खाली रहता है जब तक कि कोड पूरा नहीं हो जाता है, जिसके बाद यह एन्कोडेड है)।
2) कोड खंड
एक डेटा सेगमेंट एक प्रकार का सिफर है जिसे दो तरीकों से डिक्रिप्ट किया जा सकता है, डिक्रिप्शन के परिणामस्वरूप, पहला तरीका डेटा सेगमेंट का एक स्ट्रिंग प्रतिनिधित्व स्वयं उत्पन्न करेगा, जबकि दूसरी विधि को डिक्रिप्ट करने पर, कोड सेगमेंट का एक स्ट्रिंग प्रतिनिधित्व प्राप्त होगा। इन डिक्रिप्टेशन के परिणामों को मिलाकर, हमें एक स्ट्रिंग मिलती है जिसमें प्रोग्राम के सभी स्रोत कोड होते हैं।
उपरोक्त उदाहरण में, ऐसी रेखा 'डेटा =% s'% `डेटा` + chr (10) + डेटा है ।
'data =% s'% `data` डेटा सेगमेंट देने वाली डिक्रिप्शन है, डेटा कोड सेगमेंट देने वाला डिक्रिप्शन है, और chr (10) उनके बीच की लाइन फीड है।
और फिर, हमारे हाथों में यह जादू लाइन होने के बाद, हम इसके साथ जो चाहें कर सकते हैं। यदि हम इसे प्रिंट करते हैं, तो हमें सामान्य रूप से प्राप्त होता है:

 data = "l = 'data = %s'%`data`+chr(10)+data\nprint l" l = 'data = %s'%`data`+chr(10)+data print l 

यदि हम इसे पलट देते हैं, तो हमें एक प्रोग्राम मिलता है, जो इसके पाठ को सामने की तरफ प्रिंट करता है:

 data = "l = 'data = %s'%`data`+chr(10)+data\nprint l[-1::-1]" l = 'data = %s'%`data`+chr(10)+data print l[-1::-1] 

हम एक कार्यक्रम लिख सकते हैं जो इसके षोडश प्रतिनिधित्व को मुद्रित करता है:

 data = "l = 'data = %s'%`data`+chr(10)+data\nprint ' '.join([hex(ord(e)) for e in l])" l = 'data = %s'%`data`+chr(10)+data print ' '.join([hex(ord(e)) for e in l]) 

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

 data = [108, 32, 61, 32, 39, 100, 97, 116, 97, 32, 61, 32, 37, 115, 39, 37, 100, 97, 116, 97, 43, 99, 104, 114, 40, 49, 48, 41, 43, 39, 39, 46, 106, 111, 105, 110, 40, 91, 99, 104, 114, 40, 101, 41, 32, 102, 111, 114, 32, 101, 32, 105, 110, 32, 100, 97, 116, 97, 93, 41, 10, 112, 114, 105, 110, 116, 32, 108] l = 'data = %s'%data+chr(10)+''.join([chr(e) for e in data]) print l