एन्ट्रोपिक क्वीन!

Question

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो:

• जब पहली बार चलाया जाता है, तो अपने स्रोत कोड को आउटपुट करता है।

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

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

उदाहरण के लिए, यदि आपकी रानी थी ABCD, तो बार-बार चलने पर यह प्रिंट हो सकती है:

ABCD
A!CD
j!CD
j!CjD

विशेष विवरण

• एक चरित्र परिवर्तन या तो है:

  • एक यादृच्छिक चरित्र का सम्मिलन,
  • एक यादृच्छिक चरित्र का विलोपन, या
  • एक नए यादृच्छिक चरित्र के साथ एक चरित्र का प्रतिस्थापन। ध्यान दें कि नए चरित्र को उसी के रूप में होने की अनुमति है जो इसे बदलता है, जिस स्थिति में कोई परिवर्तन नहीं किया जाएगा।

  बेशक, किसी पात्र को खाली स्ट्रिंग से हटाना या बदलना कोई मान्य परिवर्तन नहीं है।

• इसके बावजूद किया जा रहा है टैग किया Quine , अपने स्रोत कोड को पढ़ने के खिलाफ नियम लागू नहीं होते।

आप किसी भी वर्ण सेट का उपयोग तब तक कर सकते हैं जब तक कि इसमें आपके स्रोत कोड में उपयोग किए गए वर्ण शामिल हों।

Comments

प्रत्येक वर्ण किस वर्ण का उल्लेख करता है?

— डेनिस

यह कितनी बार काम करना है? स्पष्ट रूप से यह अक्सर या अन्यथा हर संभव कार्यक्रम नहीं हो सकता है क्योंकि मूल से अधिक या लंबे समय तक हर संभव कार्यक्रम चुनौती का समाधान है।

— मार्टिन एंडर

क्या चरित्र को कहीं भी जोड़ा जा सकता है, या सिर्फ अंत में?

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

@ ConorO'Brien कहीं भी।

— फल

कितने पुनरावृत्तियों को काम करना पड़ता है?

— डायलन

Answer 1

पायथन 3 , ^{288 270 224 212 195 196 194 180 178} 168 बाइट्स

f=__file__
m=open(f).read()
x=m	
print(end=x)
h=hash
k=h(f)
n=k%2
a=h(m)%-~len(x)
x=x[:a]+(not(k%3)*x)*chr(k%127)+x[a+n:]
open(f,'w').write(m.replace("\t",";x=%r\t"%x))

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

पहली पुनरावृत्ति पर फ़ाइल स्रोत कोड को प्रिंट करने के बाद, हम मीटर के बजाय नए स्रोत कोड में x सेट करने के लिए एक अतिरिक्त रेखा को जोड़ते हैं।

स्पष्टीकरण:

f=__file__    #Open and read the source code
m=open(f).read()

x=m       #Set x to the source code for the first iteration
x="..."
...
x="..."   #Set x to the latest iteration
          #On the last iteration there's a tab character to mark progress
print(end=x)    #Print the previous iteration's text

#Modify the text
h=hash
k=h(f)            #Generate a random number to use
n=k%2             #Whether the character will be inserted or changed/deleted
a=h(m)%-~len(x) #The index of the change
                         #Add 1 to the range to append new characters, and to avoid mod by 0 in the case of an empty string
x=x[:a]+(not(k%3)*x)*chr(k%127)+x[a+n:]    #Make the change

open(f,'w').write(m.replace("\t",";x=%r\t"%x))   #Modify the source code, adding the new iteration of the source code

मान लें कि hashएक समान रूप से यादृच्छिक संख्या देता है, एक नया वर्ण सम्मिलित करने का लगभग 1/6 मौका है, एक मौजूदा चरित्र को बदलने का 1/6 मौका है और एक चरित्र को हटाने का 2/6 मौका है। शेष 2/6 मौका क्या है? क्यों, यह समय के सभी 2/6 पर कुछ नहीं करता है!

(यहाँ mbomb007 के उत्तर से अनुकूलित एक सत्यापन कार्यक्रम है । इसे ऑनलाइन आज़माएं! )

Comments

मुझे लगता f=__file__है कि पहले चरण में भी मदद मिलेगी।

— अर्जन जोहान्सन

Answer 2

पायथन 3 , 205 195 बाइट्स

s='print(end=x);h=hash;k=h(x);n=k%2;a=h(s)%-~len(x);x=x[:a]+(not(k%3)*x)*chr(k%127)+x[a+n:];open(__file__,"w").write("s=%r;x=%r;exec(s)"%(s,x))';x='s=%r;x=%r;x=x%%(s,x);exec(s)';x=x%(s,x);exec(s)

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

एक ऐसे संस्करण की कोशिश करना चाहता था जो स्रोत कोड को न पढ़े। के रूप में मैंने सोचा था कि नहीं एक बुरा निकला, और यह केवल 30 या तो पीछे बाइट्स है संस्करण है कि करता है । यह कैसे काम करता है, इसके बारे में स्पष्टीकरण अन्य उत्तर के समान ही है, लेकिन यह x को अलग तरीके से शुरू करता है क्योंकि यह स्रोत कोड को पढ़ नहीं सकता है।

Answer 3

पायथन 2 , 779 801 बाइट्स

यद्यपि यह चुनौती यह दिखाने के लिए संपादित की गई थी कि आपके स्रोत को पढ़ने की अनुमति है, मैं पहले से ही इसके बिना अपना समाधान बना रहा था। इसलिए, यह दिखाने के लिए कि यह संभव है, मैंने इसे समाप्त कर दिया। स्रोत फ़ाइल का कोई पठन नहीं:

s='s=%r;print s%%s\nfrom random import*;L=4;f=open(__file__,"wa"[L>5]);R=randint\nf.write("\\n".join((s%%s).split("\\n")[1:5:2]).replace("4",`map(ord,s%%s)`))\nif L>5:exec\'b=[];h=%%d\\nwhile~-h:b+=[h%%%%1000];h/=1000\\nwhile b:r,p,n=b[-3:];b=b[:-3];L=[L[:p]+L[p+1:],L[:p]+[r]+L[p+n:]][n<2if L else 1]\\nprint"".join(map(chr,L))\'%%1\n\nn=R(0,2);p=R(0,len(L if L>5else s%%s));r=R(0,255);f.write("%%03d"*3%%(n,p,r))';print s%s
from random import*;L=4;f=open(__file__,"wa"[L>5]);R=randint
f.write("\n".join((s%s).split("\n")[1:5:2]).replace("4",`map(ord,s%s)`))
if L>5:exec'b=[];h=%d\nwhile~-h:b+=[h%%1000];h/=1000\nwhile b:r,p,n=b[-3:];b=b[:-3];L=[L[:p]+L[p+1:],L[:p]+[r]+L[p+n:]][n<2if L else 1]\nprint"".join(map(chr,L))'%1

n=R(0,2);p=R(0,len(L if L>5else s%s));r=R(0,255);f.write("%03d"*3%(n,p,r))

इसे ऑनलाइन आज़माएं! (ध्यान दें कि यह स्रोत को संशोधित नहीं करेगा। आपको इसे काम करने के लिए स्थानीय रूप से चलाना होगा)

पता चलता है कि परिवर्तनों काम करते हैं, यहाँ एक है परीक्षण कार्यक्रम (वर्तमान में हमेशा लेने के लिए की स्थापना 100के लिए r, और इसके बारे में हर संयोजन के लिए परिणाम प्रिंट nऔर pप्रारंभिक सूची के लिए।)

---

स्पष्टीकरण:

s='s=%r;print s%%s...';print s%s...

पहली पंक्ति आपकी क्लासिक क्वीन है, लेकिन उसके बाद जो आता है उसके लिए बहुत अधिक समय तक ध्यान देना चाहिए।

from random import*;L=4;f=open(__file__,"wa"[L>5]);R=randint

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

f.write("\n".join((s%s).split("\n")[1:5:2]).replace("4",`map(ord,s%s)`))

कोड की पहली और तीसरी लाइन निकालें। 4अध्यादेशों की सूची के साथ उपरोक्त बदलें ।

if L>5:exec'b=[];h=%d\nwhile~-h:b+=[h%%1000];h/=1000\nwhile b:r,p,n=b[-3:];b=b[:-3];L=[L[:p]+L[p+1:],L[:p]+[r]+L[p+n:]][n<2if L else 1]\nprint"".join(map(chr,L))'%1

n=R(0,2);p=R(0,len(L if L>5else s%s));r=R(0,255);f.write("%03d"*3%(n,p,r))

टुकड़ों में:

• if L>5:- पहले निष्पादन पर इस लाइन को छोड़ देता है। बाद में, Lएक सूची होगी, और यह चलेगा। मैं execआखिरी समझाता हूँ , क्योंकि यह पहली बार नहीं चला है।

• n- एक यादृच्छिक संख्या 0-2। यह निर्धारित करता है कि कौन सा संशोधन होता है (0 = सम्मिलित करें, 1 = प्रतिस्थापित करें, 2 = हटाएं)।

• p - सूची में एक यादृच्छिक स्थिति जो संशोधन पर होगी।

• r - सूची में सम्मिलित करने या बदलने के लिए एक यादृच्छिक संख्या

• f.write("%03d"*3%(n,p,r))- स्रोत फ़ाइल के अंत में 3 रैंडम संलग्न करें। प्रत्येक रन, यह एक पूर्णांक पर जोड़ रहा होगा जो कि होने वाले प्रारंभिक स्रोत में सभी परिवर्तनों को एन्कोड करता है।

• exec'b=[];h=%d...'%1...- यादृच्छिक संख्याएं प्राप्त करें ( %1बाद में चलने के बाद मिली ), सूची में परिवर्तन लागू करें, और प्रिंट करें।

• while~-h:b+=[h%%1000];h/=1000- अब तक उत्पन्न रैंडम की एक सूची बनाएं 1, जो प्रमुख के लिए लेखांकन है , जो अग्रणी शून्य के साथ समस्याओं को रोकता है।

• while b:r,p,n=b[-3:];b=b[:-3] - इस पुनरावृत्ति के लिए रैंडम असाइन करें।

• L=[L[:p]+L[p+1:],L[:p]+[r]+L[p+n:]][n<2if L else 1] - (0 = सम्मिलित करें, 1 = बदलें, 2 = हटाएं)

• print"".join(map(chr,L)) - संशोधित स्रोत मुद्रित करें।

Comments

क्या यह कभी-कभी स्ट्रिंग के अंत से एक गैर-मौजूद चरित्र को हटा देता है? चूंकि pस्ट्रिंग की लंबाई हो सकती है। इसके अलावा, एक खाली स्ट्रिंग के साथ व्यवहार क्या है?

— जो किंग

@ जॉकिंग मैंने एक परीक्षण कार्यक्रम जोड़ा। हर संभव चरित्र परिवर्तन हो सकता है। यह सिर्फ दिखाता है कि हर स्थिति को सम्मिलित करने, बदलने या हटाने के लिए चुना जा सकता है, और यह एक खाली सूची को संभालता है। tio.run/##LYoxDsMgDEVnOAUjCAZgRO0NuIHloUOaRIocy6JDT08dpdt/…

— mbomb007

मुझे नहीं लगता कि कोई भी बदलाव मान्य नहीं है, हालांकि मैंने ओपी से पूछा है। सवाल कहता हैOf course, deleting or replacing a character from an empty string is not a valid change

— जो राजा

मैं Esolanging फल पूछा है, और वे कहते हैं कि कोई परिवर्तन नहीं है मान्य है, लेकिन कोई रिक्त स्ट्रिंग के लिए नहीं।

— जो राजा

@ जोकिंग को ठीक किया जाना चाहिए।

— mbomb007

Answer 4

जावा 10, 370 बाइट्स

String s;v->{if(s==null){s="String s;v->{if(s==null){s=%c%s%1$c;s=s.format(s,34,s);}else{int r=s.length();r*=Math.random();char c=127;c*=Math.random();s=s.substring(0,r)+(c%%3<2?c:%1$c%1$c)+s.substring(r+(c%%3>0?1:0));}}";s=s.format(s,34,s);}else{int r=s.length();r*=Math.random();char c=127;c*=Math.random();s=s.substring(0,r)+(c%3<2?c:"")+s.substring(r+(c%3>0?1:0));}}

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

स्पष्टीकरण:

String s;               // Class-level String variable to store the modifying source code
v->{                    // Method without parameter nor return-type
  if(s==null){          //  If this is the first execution of this function:
    s="String s;v->{if(s==null){s=%c%s%1$c;s=s.format(s,34,s);}else{int r=s.length();r*=Math.random();char c=127;c*=Math.random();s=s.substring(0,r)+(c%%3<2?c:%1$c%1$c)+s.substring(r+(c%%3>0?1:0));}}";
                        //   Set `s` to the unformatted source-code
    s=s.format(s,34,s);}//   And then to the formatted source-code
else{                   //  For any following executions of this function:
  int r=s.length();r*=Math.random();
                        //   Random index in range [0, length_of_modified_source_code)
  char c=127;c*=Math.random();
                        //   Random ASCII character in unicode range [0, 127)
  s=                    //   Replace the current String `s` with:
    s.substring(0,r)    //    The first [0, `r`) characters of the modified source code `s`
    +(c%3<2?            //    If the random option is 0 or 1:
           c:"")        //     Append the random character
        +s.substring(r  //    Append the rest of the modified source code `s`, but:
          +(c%3>0?      //     If the random option is 1 or 2:
             1:0));}}   //      Skip the first character of this second part

सामान्य स्पष्टीकरण:

क्वीन -पार्ट :

• स्ट्रिंग sमें बिना स्रोत वाला स्रोत कोड होता है।
• %sइस स्ट्रिंग को स्वयं के साथ इनपुट करने के लिए उपयोग किया जाता है s.format(...)।
• %c, %1$cऔर 34डबल-कोट्स को फॉर्मेट करने के लिए उपयोग किया जाता है।
• ( %%modulo- को फॉर्मेट करने के लिए प्रयोग किया जाता है %)।
• s.format(s,34,s) यह सब एक साथ रखता है।

यहां एक मूल जावा क्वीन प्रोग्राम है।

चुनौती हिस्सा:

• String s; वह स्रोत कोड है जिसे हम कक्षा-स्तर पर संशोधित करेंगे।
• int r=s.length();r*=Math.random();सीमा में स्रोत कोड के एक यादृच्छिक सूचकांक का चयन करने के लिए उपयोग किया जाता है [0, length_of_modified_source_code)।
• char c=127;c*=Math.random();यूनिकोड श्रेणी में एक यादृच्छिक ASCII वर्ण (unprintables सहित) का चयन करने के लिए उपयोग किया जाता है [0, 126]।
• c%3का उपयोग यादृच्छिक विकल्प या तो 0, 1 या 2 का चयन करने के लिए किया जाता है। विकल्प 0 इंडेक्स से पहले यादृच्छिक वर्ण जोड़ देगा r; विकल्प 1 rयादृच्छिक चरित्र के साथ सूचकांक में चरित्र को बदल देगा ; और विकल्प 2 सूचकांक पर चरित्र को हटा देगा r।