मार्कोव चैन क्वीन

Question

इस प्रश्न में एक सरल मार्कोव मॉडल का उपयोग किया जाएगा। मार्कोव चेन के बारे में अधिक जानकारी के लिए, http://setosa.io/ev/markov-chains/ देखें ।

एक तार ले लो। इस उदाहरण के लिए, हम इस शब्द का उपयोग करेंगे:

reader

अब, प्रत्येक वर्ण के लिए, उन पात्रों को लें जो स्ट्रिंग में वर्ण की प्रत्येक घटना के बाद दिखाई देते हैं। ( ​`^`​स्ट्रिंग की शुरुआत का ​`$`​प्रतिनिधित्व करता है और अंत का प्रतिनिधित्व करता है)

`^` -> {'r'}       # After the start of the string, there is an `r`.
'r' -> {'e', `$`}  # After the first `r` (*r*eader), there is an `e`
                   # after the second (reade*r*), there is the end of the string.
'e' -> {'a', 'r'}
'a' -> {'d'}
'd' -> {'e'}

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

r
rereader
rer
readereader

यदि एक चरित्र कई बार किसी अन्य चरित्र के बाद दिखाई देता है, तो इसे चुने जाने की अधिक संभावना है। उदाहरण के लिए, में cocoa can, एक के बाद c, एक होने का एक मौका का एक दो तिहाई है और एक होने का oएक तिहाई मौका है a।

'c' -> {'o', 'o', 'a'}

चुनौती

एक प्रोग्राम बनाएं जो कोई इनपुट नहीं लेता है और ऊपर की तरह एक मार्कोव चेन का उपयोग करके उत्पन्न एक यादृच्छिक स्ट्रिंग को आउटपुट करता है, जहां श्रृंखला का इनपुट प्रोग्राम का स्रोत है।

1. कार्यक्रम में कम से कम दो वर्ण होने चाहिए, जिनमें से दो समान होने चाहिए ("उबाऊ" श्रृंखला को रोकने के लिए जिसमें केवल एक आउटपुट हो)
2. यदि आप चाहें तो पात्रों के बजाय बाइट्स का उपयोग करने के लिए मॉडल को संशोधित कर सकते हैं, लेकिन नियम 1 में "वर्ण" को "बाइट्स" में बदल सकते हैं
3. कार्यक्रम को सिद्धांत में अपेक्षित आवृत्ति के साथ बेतरतीब ढंग से तारों का उत्पादन करना चाहिए

यह कोड-गोल्फ है , इसलिए सबसे छोटा कार्यक्रम जीतता है!

Comments

@ mbomb007 सभी जानकारी प्रश्न में है, यदि आप रुचि रखते हैं तो लिंक अतिरिक्त है (यह एक बहुत ही मूल कार्यान्वयन है)

— Artyer

क्यों कर रहे हैं ^और $में उद्धरण? हो सकता है कि इसे उद्धरणों से बाहर ले जाना, या उन्हें बैकक्वाटर में रखना अधिक स्पष्ट हो।

— विनाशकारी नींबू

Answer 1

पिप , 64 बाइट्स

यह मजेदार था।

t:V Y\"m:"Yt@0T9=A OyY@>RC(t(Xy).'.)"ST["t:V Y"RPy";Vm"C9]\";Vm<tab>

<tab>एक शाब्दिक टैब वर्ण ( 0x09) का प्रतिनिधित्व करता है । इसे ऑनलाइन आज़माएं!

कैसे?

टीएल; डीआर: बच गए-स्ट्रिंग सिंटैक्स, रीप्र, और ईवैल।

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

V Y\""V Y".RPy\"

वह है: Yak (storing as y) जिसमें एक स्ट्रिंग होती है "V Y".RPyऔर e Val al होती है। RPyके लिए ले जाता है y, जिसके लिए हम शाब्दिक स्ट्रिंग प्रस्तुत करते हैं V Y। अंत में, निष्कासन के परिणाम को आउटपुट करें।

मार्कोव क्वीन की संरचना समान है, सिवाय इसके कि हम इसे आउटपुट करने के बजाय कोड को सहेजना चाहते हैं और फिर बाद में इसके साथ कुछ सामान करते हैं। t:V Y\"...\"के लिए eval परिणाम प्रदान करता है t। Eval'd कोड के अंदर, कोड की m:"..."एक स्ट्रिंग प्रदान करता है m, जिसका हम अंत में मूल्यांकन करेंगे Vm।

ST["t:V Y"RPy";Vm"C9] एक सूची युक्त बनाता है

"t:V Y"  Literal string
RPy      Repr(y)
";Vm"    Literal string
C9       Tab character

और इसे एक स्ट्रिंग में परिवर्तित करता है, जो डिफ़ॉल्ट रूप से सभी मदों को मिलाता है। यह खंड "V Y".RPyमूल क्वीन में बराबर है । चूंकि यह बड़ी निकासी स्ट्रिंग में अंतिम अभिव्यक्ति है, इसलिए इसका मूल्य वही है जो Vऑपरेटर वापस लौटाता है, और इस प्रकार जिसे सौंपा जाता है t।

इस प्रकार, निष्कासन और असाइनमेंट के बाद, tपूर्ण कोड के बराबर है, और mइसमें शामिल है

Yt@0T9=A OyY@>RC(t(Xy).'.)

अब Vmकोड के रूप में इसका मूल्यांकन करता है। जो होता है उसे तोड़ देते हैं।

                            We'll use y to hold the current character in the chain
Yt@0                        Yank first character of t into y (chain always starts there)
         Oy                 Output y without newline each time we...
    T9=A                    Loop till ASCII code of y equals 9 (tab)
                            Since there's only one literal tab, at the end of the program,
                              this satisfies the Markov chain ending requirement
                   Xy       Generate a regex that matches y
                  (  ).'.   Concatenate . to regex: now matches y followed by any character
                (t       )  Find all matches in t (returns a list)
              RC            Random choice from that list
           Y@>              Slice off the first character and yank the remaining one into y

एक दो नोट:

• एक शाब्दिक टैब के साथ कोड को समाप्त करना "अगले चरित्र या स्ट्रिंग के अंत" के लिए एक रेगेक्स टेस्ट करने से कम था।
• मेरे द्वारा उपयोग किया गया रेगेक्स ठीक से काम नहीं करता है अगर कोड में दोहरे अक्षर हैं; उदाहरण के लिए, इसे लागू करने के लिए xxyकेवल वापसी होगी xxऔर न xyमैचों में। सौभाग्य से, हालांकि, इस कोड में कोई भी दोहरे चरित्र नहीं हैं, इसलिए यह कोई फर्क नहीं पड़ता।

Answer 2

जावास्क्रिप्ट, 217 215 बाइट्स

a="a=q;a=a.replace('q',uneval(a));for(b=c='a';d=a.split(c),c=d[Math.random()*~-d.length+1|0][0];b+=c);alert(b)";a=a.replace('q',uneval(a));for(b=c='a';d=a.split(c),c=d[Math.random()*~-d.length+1|0][0];b+=c);alert(b)

ध्यान दें कि यह उपयोग करता है uneval, जो केवल फ़ायरफ़ॉक्स द्वारा समर्थित है। नमूना चलता है:

a=ale(a.lend[Ma=d[Macepla.ler(b+=c)b=q;fom(a=q;a=dort(b+1|0],c);a.lit(a)
at(c=c;d[0],c=q;ath+1|0][0];dorerac=ac=d[Ma),c;)*~-d[Ma=alenepl(b+=ac=c;a=c;d[2];d.re(c;fom()
a="a[0],und=d=a)
angt(b),und=d.l(b=a)
a)
ale(a.rth.revanepleplit(b)
ac);fore(b)*~-d.r(b+1|0];fora';a)*~-d.splalith+=dorth+=c=";ath+=a.length+=';ale(b)
a.r(b=c=a)b+1|0],und[0][0];d.splerath.spleneva)";ath.r(ceneplith+=d=aceple(c;)*~-d=';ala';)b='ac;fom(b=c;a.ler(b=d=d[Ma.rt(c=cendor()*~-d='a=";ac;a.spla)b=ceva=';a=d.rt(angt(alength+1|0],c;angt()
al(ac=dorth+1|0][0][0][0][Ma.split()

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

---

यदि स्व-पठन कार्यों की अनुमति थी, तो यह ES6 के 78 बाइट्स हो सकते हैं:

f=(c="f",p=("f="+f).split(c),q=p[Math.random()*~-p.length+1|0][0])=>q?c+f(q):c

बहुत, बहुत कम, यह जेनेटिक रूप से मान्य जेएस आउटपुट करता है:

f=>e?c+f():c
f=>e?c=>engt():c
f=>e?c=(e):c
f=>e?c=>e=>ength.split():c
f=p=>q?c+f():c
f(q).sp=",p[Mat(q?c=(),plith.lith.sp.sp[0]).lendom().lith+f=>q=p.lendom(",p=p=>q?c+f():c
f(q),q?c=(c=(q)*~-p[0]):c
f().random(),q?c=(c=p[0]):c
f=>q?c=(q="+f"+f).rath.split(c):c
f="+1|0])=().lith.rat()*~-p=>q?c=p[Mat(c=",q?c=p.rath.splendom()*~-plength.splith.lendom(c):c

मेरे द्वारा बनाए गए फ़ंक्शन नामों का मेरा पसंदीदा है .splendom()( split+ length+ random)

Comments

मुझे आश्चर्य है कि इस वैध जावास्क्रिप्ट को उत्पन्न करने की संभावना क्या है। (बेवकूफ स्निप चेतावनी)

— DanTheMan

@DanTheMan निश्चित रूप से बहुत, बहुत कम। बस सभी कोष्ठक और कोष्ठक संतुलित होने की संभावना अविश्वसनीय रूप से कम है। हालाँकि मुझे एक बार मिला a.splerength.r(), जो वैध हो सकता है;)

— ETHproductions

यह ध्यान रखना चाह सकते हैं कि यह FF केवल यूवेअल के उपयोग के कारण है

— Shaun H

@ शुहान धन्यवाद, मैं यह भूल गया कि केवल एफएफ केवल समर्थन करता है।

— ETHproductions

दूसरी आत्म पढ़ने समारोह मान्य नहीं है ( meta.codegolf.stackexchange.com/a/4878/48878 के अनुसार, "एक Quine अपने स्वयं के स्रोत का उपयोग नहीं करना चाहिए, प्रत्यक्ष या परोक्ष।"), और @DanTheMan jsfiddle.net / kabkfLak / 1 , मौका लगभग 6.3% होना चाहिए।

— एरियर

Answer 3

पर्ल, 103 बाइट्स

मानक क्वीन और इस सवाल के मेरे जवाब के आधार पर :

$_=q{$_="\$_=q{$_};eval";@s='$';{push@s,(@n=/(?<=\Q$s[-1]\E)(.|$)/g)[rand@n];$s[-1]&&redo}print@s};eval

उदाहरण आउटपुट

$_=q{$_=q{$_=";@sh@s=";eval
$_="\$_=q{$_='$_=q{$_}pus=\$_=";@n=";@ndo};{pus=';edo};@n]\Q$_};{$_};@s=q{$_=';@s[rand@s=/g)(@s,(@s,(@sh@s[-1];@ndo};ed@s[-1]\E)(.|$_}prevan]&ral";evan];{$_}pus='$_};ed@sh@sh@s[-1]\$_='$_};evando};eval
$_=q{$_=";ed@s[-1];evand@s="\Q$_=";@s[-1]\Q$_=q{$_=";@nd@sh@sh@s='$_=q{$_=q{$_='$_="\Q$_='$_};{pus=\$_=q{$_}pral
$_=";evando};@nd@sh@s,(@n]\$_=";@s,(@s[-1];{$_=q{$_}pral
$_=";eval
$_='$_=q{$_="\$_="\Q$_=";ed@sh@s=\E)(.|$_=q{$_=q{$_=q{$_=q{$_}pus=/(?<=q{$_};eval
$_=";ed@sh@s[-1]\Q$_=';edo};{$_=q{$_=";@nt@s,(@n]&&&&&&&ral";@nd@s,(@s[-1]\$_}pus=\E)(.|$_=';@nt@s[ral

अन्य प्रश्न के समान, कुछ परिणाम मान्य पर्ल उत्पन्न करते हैं:

$_=q{$_};{$_};eval";@sh@s[-1]\$_='$_};evan]\Q$_}preval";eval
$_=q{$_};{$_=q{$_=';@nd@s=q{$_};@s[-1]\E)(@s[-1]\E)(@n=';edo};{$_}predo};eval
$_=q{$_=q{$_};edo};@n=q{$_=q{$_};@s[rin='$_=q{$_}pus=/g)(.|$_=q{$_};edo};eval
$_=q{$_};eval
$_=q{$_=";@ndo};{$_}preval

लेकिन संभावना थोड़ा कम है, ~ 2% पर।

Comments

यदि आपने मुझे बताया कि पहला उदाहरण वैध पर्ल था तो मुझे विश्वास होगा कि आप।

— अंख-मोर्फर्क

@ dohaqatar7 मैंने पहली बार आपकी टिप्पणी को गलत समझा और सोचा कि अगर मुख्य कोड वैध पर्ल था तो मैंने मुझ पर विश्वास नहीं किया होगा ...: D zoitz.com/comics/perl_small.png

— डोम हेस्टिंग्स

@ akh-morpork: यह स्पष्ट रूप से अमान्य है, q{एक स्ट्रिंग शाब्दिक की शुरुआत है और }इसे बंद करने के लिए कोई भी नहीं है। पर्ल का वास्तव में बाइट्स के यादृच्छिक क्रम को चलाने में काफी बुरा है (और जब ऐसा होता है, तो यह आमतौर पर शुरुआती स्ट्रिंग शाब्दिक या टिप्पणी के कारण होता है)।

Answer 4

MS-DOS मशीन कोड (.COM फ़ाइल), 63 बाइट्स - गैर-प्रतिस्पर्धात्मक

गैर-प्रतिस्पर्धा क्योंकि एक क्वीन को अपने स्वयं के स्रोत कोड तक नहीं पहुंचना चाहिए।

एक 126-बाइट संस्करण "अपने स्वयं के स्रोत कोड तक नहीं पहुंच" आवश्यकता को पूरा करेगा!

63 बाइट वेरिएंट इस तरह दिखता है:

FC BE 00 01 AC 50 88 C2 B4 02 CD 21 E8 1A 00 59
4E AC 81 FE 3F 01 7C 03 BE 00 01 38 C1 75 F2 FE
CA 75 EE 81 FE 00 01 75 DB 8A 16 00 80 31 C0 8E
D8 31 C9 AC 00 C2 E2 FB 0E 1F 88 16 00 80 C3

मैं यादृच्छिक जनरेटर की संभाव्यता वितरण के बारे में निश्चित नहीं हूं:

कार्यक्रम इस तथ्य का उपयोग करता है कि घड़ी काउंटर और इंटरप्ट द्वारा संशोधित अन्य जानकारी यादृच्छिक संख्या उत्पन्न करने के लिए खंड 0 में संग्रहीत हैं।

उत्पन्न आउटपुट के उदाहरण हैं:

FC BE 00 01 7C 03 BE 00 80 C3

FC BE 00 01 38 C1 75 F2 FE 00 80 31 C9 AC 81 FE 00 80 C3

FC BE 00 01 38 C1 75 EE 81 FE 00 01 38 C1 75 EE 81 FE CA
75 F2 FE 00 01 75 F2 FE 00 80 C3

FC BE 00 C2 B4 02 CD 21 E8 1A 00 01 7C 03 BE 00 59 4E AC
81 FE 3F 01 AC 81 FE 3F 01 7C 03 BE 00 01 7C 03 BE 00 01
AC 81 FE 3F 01 7C 03 BE 00 80 C3

विधानसभा कोड में परिवर्तित कार्यक्रम इस तरह दिखता है:

    cld                # Ensure SI is being incremented
    mov si, 0x100      # Move SI to the first byte of the program
nextOutput:
    lodsb              # Load one byte of the program ...
    push ax            # ... save it to the stack ...
    mov dl, al         # ... and output it!
    mov ah, 2
    int 0x21
    call pseudoRandom  # Create a random number (in DL)
    pop cx             # Take the stored byte from the stack
    dec si             # Go back to the last byte loaded
nextSearch:
    lodsb              # Load the next byte
    cmp si, programEnd # If we loaded the last byte ...
    jl notEndOfProgram # ... the next byte to be loaded ...
    mov si, 0x100      # ... is the first byte of the program.
notEndOfProgram:
    cmp cl, al         # If the byte loaded is not equal to ...
                       # ... the last byte written then ...
    jne nextSearch     # ... continue at nextSearch!
    dec dl             # Decrement the random number and ...
    jnz nextSearch     # ... continue at nextSearch until the ...
                       # ... originally random number becomes zero.
    cmp si, 0x100      # If the last byte read was not the last byte ...
    jnz nextOutput     # ... of the program then output the next ...
                       # ... byte!

    # Otherwise fall through to the random number generator
    # whose "RET" instruction will cause the program to stop.        

    # The random number generator:
pseudoRandom:
    mov dl, [0x8000]   # Load the last random number generated
                       # (Note that this is uninitialized when
                       # this function is called the first time)
    xor ax, ax         # We use segment 0 which contains the ...
    mov ax, ds         # ... clock information and other data ...
                       # ... modified by interrupts!
    xor cx, cx         # Prepare for 0x10000 loops so ...
                       # ... all bytes in the segment are processed ...
                       # ... once and the value of SI will be ...
                       # ... unchanged in the end!
randomNext:
    lodsb              # Load one byte
    add dl, al         # Add that byte to the next random number
    loop randomNext    # Iterate over all bytes
    push cs            # Restore the segment
    pop ds
    mov [0x8000], dl   # Remember the random number
    ret                # Exit sub-routine

programEnd:

Comments

गैर-प्रतिस्पर्धा उन उत्तरों के लिए आरक्षित है जो चुनौती के मानदंडों को पूरा करते हैं लेकिन चुनौती की तुलना में एक भाषा या सुविधा का उपयोग कर रहे हैं। या तो वह वेरिएंट पोस्ट करें, जो स्वयं के स्रोत को नहीं पढ़ता है, या उत्तर को हटा दें।

— mbomb007

Answer 5

सी, 306 328 585 611 615 623 673 707 बाइट्स

सोर्स कोड:

p[256][256]={0};char*X="p[256][256]={0};char*X=%c%s%c,Y[999],c,j,*a;main(){sprintf(Y,X,34,X,34);for(a=Y;*a;a++)p[*a][*(a+1)]++;for(j=*Y;putchar(c=j);)while(p[c][++j]<<16<rand());}",Y[999],c,j,*a;main(){sprintf(Y,X,34,X,34);for(a=Y;*a;a++)p[*a][*(a+1)]++;for(j=*Y;putchar(c=j);)while(p[c][++j]<<16<rand());}

सुस्पष्टता / स्पष्टीकरण के लिए नई कहानियों और व्हाट्सएप के साथ जोड़ा गया:

01  p[256][256]={0};
02  char*X="p[256][256]={0};char*X=%c%s%c,Y[999],c,j,*a;main(){sprintf(Y,X,34,X,34);for(a=Y;*a;a++)p[*a][*(a+1)]++;for(j=*Y;putchar(c=j);)while(p[c][++j]<<16<rand());}",
03  Y[999],c,j,*a;
04  main(){
05      sprintf(Y,X,34,X,34);
06      for(a=Y;*a;a++)p[*a][*(a+1)]++;
07      for(j=*Y;putchar(c=j);)
08          while(p[c][++j]<<16<rand());
09  }

व्याख्या

Line 01: p[][]एक चरित्र के मायने रखता है दूसरे के बाद।

Line 02: Xकार्यक्रम का स्रोत है, के साथ भाग गया %c%s%c।

Line 03: Yकार्यक्रम का शाब्दिक स्रोत होगा। c, j, *aउनकी गिनती चर हैं।

Line 05: Yरानी को शामिल करने के लिए सेट करें ।

Line 06: गिनती पत्र घटनाओं में p[][]।

Line 07: वर्तमान स्थिति मुद्रित करें।

Line 08: बेतरतीब ढंग से अगले वर्ण का पता लगाएं, जिसमें मायने रखता है p[][]।

नमूना उत्पादन:

p[++);p[99]=Y;putfor(aind(a++j,*a+j=j,c][c,*an(arile(pr*Y,Y[256]<<1);)][*Y,Y;)wha+++j=*aintfor*Y;prin(a+j]=j][256<1)pr(a;a;f(p[char(Y;for());};a;ma;ma=%s%chain(Y;ar(j][256<<<1)p[256<<raile(cha][9]<rin(j,34,34,Y[256]+j,Y,34,Y,c=Y,*a;*a;for(){0}

Comments

क्या आप नए संस्करण और व्हाट्सएप के बिना एक संस्करण जोड़ सकते हैं ताकि हम बाइट काउंट को सत्यापित कर सकें?

— स्टीवन एच।

हां, मैंने शीर्ष पर एकल पंक्ति संस्करण जोड़ा है।

Answer 6

रूबी, 152 बाइट्स

0;s="0;s=%p<<33
0until putc($/=Hash[[*(s%%s).chars.each_cons(2)].shuffle][$/])==?"<<33
0until putc($/=Hash[[*(s%s).chars.each_cons(2)].shuffle][$/])==?!

नमूना उत्पादन:

0;s.c($/=Has(s).ears(2).ch[*(2)=Hacontc(2).ears.eas=Has==Hars%putc($/]).ears%sh_chuffl puns=Hachach[$/==?!

या

0;s.ch[*($/=%pufl puns($/=%s.shas($/=Harsh_chutilears)])].e]).s)=Hac($/=="<<33\ntile].chufffle][[$/=Hars%sh_c(2)=%p<<<<<33
0;s)].ears)=Hars).c(s).eacon0un0;sh_c($/][*(s.s=Hacons=?!

स्ट्रिंग स्वरूपण के माध्यम से उपयोग "s%s"करता है, और मार्कोव सभी दो-चरित्र के स्लाइसें लेते हुए, उन्हें फेरबदल करते हुए, और हैश शब्दकोश में बदल देता है, जहां डुप्लिकेट कुंजियों के लिए अंतिम स्वरूप मान को परिभाषित करता है। शुरुआत के लिए अतिरिक्त तर्क जोड़ने से बचने के लिए, मैं सबसे हाल ही में आउटपुट चरित्र का उपयोग करके ट्रैक करता हूं $/, जो स्वचालित रूप से एक नई रेखा पर आरंभीकृत होता है, और यह सुनिश्चित करता है कि कोड में हमेशा नईलाइनों का पालन किया जाता है 0, वही चरित्र कोड के साथ शुरू होता है। अंत के लिए, मैं स्रोत कोड में हेरफेर करता हूं ताकि केवल एक ही हो !ताकि हम बैंग के बाद हमेशा समाप्त हो जाएं, <<33इसे शाब्दिक के बिना जोड़ने के लिए। यह ASCII 33 के बजाय एक unprintable एकल-अंकीय चरित्र का उपयोग करके आगे बढ़ाया जा सकता है, लेकिन यह बहुत कष्टप्रद लग रहा था।

Comments

p<<<<<33सुपर-सुपर-सुपर-कॉनैट ऑपरेटर? ;-)

— ETHproductions

यह "वायाए से कम" ऑपरेटर है।

— mbomb007

मुझे इस शब्द से प्यार है! तथ्य यह है कि यदि वस्तु Has(s).ears(2)मुझे चकली बना देती है तो पहला उदाहरण है !

— डोम हेस्टिंग्स 19

Answer 7

जंग, 564 बाइट्स (प्रतिस्पर्धी नहीं)

extern crate rand;fn main(){let t=("extern crate rand;fn main(){let t=", ";let mut s=format!(\"{}{:?}{}\",t.0,t,t.1).into_bytes();s.push(0);let mut r=rand::thread_rng();let mut c=s[0];while c!=0{print!(\"{}\",c as char);let u=s.windows(2);c=rand::sample(&mut r,u.filter(|x|x[0]==c),1)[0][1];}}");let mut s=format!("{}{:?}{}",t.0,t,t.1).into_bytes();s.push(0);let mut r=rand::thread_rng();let mut c=s[0];while c!=0{print!("{}",c as char);let u=s.windows(2);c=rand::sample(&mut r,u.filter(|x|x[0]==c),1)[0][1];}}

चूँकि मैंने पहले से ही एक और प्रश्न के लिए एक बहुत ही साफ सुथरा रस्ट क्वीन लिखा था, मैंने सोचा कि मैं इसे इसके लिए अनुकूलित करूँगा, क्योंकि यह काफी सरल लग रहा था। हालांकि मूल छोटा था, हालांकि, इसके लिए मैंने आकार को कम करने का बहुत कम प्रयास किया है। यहां बताया गया है कि क्या हो रहा है:

// Random numbers are removed from the standard library in Rust,
// I had to make a cargo project to even compile this...
// Rust is hardly a golfing language.
extern crate rand;

fn main(){

    // The quine is fairly simple, we just make a tuple with 
    // "everything before this tuple" as first element, and
    // "everything after this tuple" with any quotes escaped 
    // as second. That makes it really easy to print.
    let t=("[...before...]", "[...after...]");

    // Instead of printing it, we save it as a byte vector
    // and append 0
    let mut s=format!("{}{:?}{}",t.0,t,t.1).into_bytes();
    s.push(0);

    // Start with the first character
    let mut c=s[0];
    let mut r=rand::thread_rng();

    while c!=0 {
        print!("{}",c as char);

        // We slide a 2 wide window over it to save a vector
        // of all bigrams. 
        let u=s.windows(2);

        // Filter it to only those which have the current character 
        // as first. Take one at random, its second is our next 
        // character.
        c=rand::sample(&mut r, u.filter(|x|x[0]==c), 1)[0][1];

        // Keep at it until the 0 byte is generated.
    }
}

नमूना उत्पादन 1:

eran(),0{ller=samarin chas c).pr,teteran mut madoletet manthilaplerng().wind_byt.wit();let.u.0][*s=[*s.plleas.wshit, rnd:Vec<_byte mputextet ut t leat=r,t rant!=r().filllet rng();lar("{}{let.ind_byt.what amusarando_ramut!=st ct!(\").0]=colet!(&lec<_ret.plec=s.whrararandormpr=saile ret=r,0]=r);le(\"),t und;fint.prilt!();ler(2).forap(&ler=s(),t ut rat mu:t=ramund:Ve s.putec==[0];wst and_byt sh(\"et c s[1), munwhras[0];c=s=s="etornws(2)[0, ain(|x|x[0,0,0];fowile c ct(&l=",tes().co_byt().wrmat ash(|x|x[*s.lethrant.wrarmu.file(\"et, r==[1);uterile().0,t ando_rinwhas=[0{}"ect.wilant!("{ple mut, mut mamprmant,0];le(&lec=s.1),t co_>=fin mamustec!(\",c=[0];}}",0];leteteat.ust(",ternwhashrarmut ler("erat,0]==file and_reter==s.utet an letet.ut=", ras.1);fin("{:?}"et t letes[*sado_bytet rnd::Verain s[0];whant(){}{}\"echin s(2);lerad;wst reth(\",t u.iletermat c 1];}{}

नमूना आउटपुट 2:

et!().0][0][0{}

Answer 8

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

परिणाम को आउटपुट करता है stderr।

import random;X='q=[(list(t)+["$$"])[i+1]for i in range(len(t))if t[i]==c];c=random.choice(q)\nif c=="$$":exit(o)\no+=c\nexec X';s='import random;X=%r;s=%r;q=t=s%%(s,X);o=c="i";exec X';q=t=s%(s,X);o=c="i";exec X

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

नमूना उत्पादन:

i+[(s,X)));exenit(or;q=rt(t(t(t);o='ic\n(q)+1]=c\ndor randort))\ngeno));X)\nge(st))ic]=";oic=%ran(s%%(s%rt(q)\ngexe(s=st(t[(s=[if X=%(ompoiforanom;e(t X="$"$"ic="$"i";X=c rt X

संक्षिप्त विवरण:

• यह प्रोग्राम s='s=%r;print s%%s';print s%sक्वीन प्रारूप का उपयोग करता है । मैं एक तार पैदा करता हूंs , जिसमें पूरा कार्यक्रम होगा।
• डोर X में पुनरावर्ती रूप से निष्पादित करने की प्रक्रिया है।
• प्रक्रिया आउटपुट स्ट्रिंग का निर्माण करती है o, जिसे stderrमार्कोव श्रृंखला के अंत तक पहुंचने पर मुद्रित किया जाएगा ।
• श्रृंखला के अंत को $$दो वर्णों का उपयोग करते हुए, स्ट्रिंग द्वारा दर्शाया गया है , ताकि यह कार्यक्रम सभी तारों के लिए काम करेगा। मैं अपने कार्यक्रम में नहीं जैसे चरित्र का उपयोग कर सकता था chr(0), लेकिन मुझे लगता है कि यह अधिक लंबा है।
• प्रत्येक निष्पादन को चुने गए चरित्र को रखा गया है c, जो (साथ में o) कार्यक्रम के पहले चरित्र के लिए आरंभिक है।
• cस्ट्रिंग में पसंद की प्रत्येक घटना का अनुसरण करने वाले वर्णों की सूची t(स्रोत कोड की क्वीन धारण करने वाली चर) है q, जिसे अगले चयन के लिए चुना जाएगा c।

Answer 9

PHP, 144 135 130 120 272 220 212 बाइट्स

<?$e='$p=$n="";foreach(str_split($s)as$w)$p=$m[$p][]=$w;do echo$n=$m[$n][array_rand($m[$n])];while("\n"!=$n);
';$s='<?$e=%c%s%1$c;$s=%1$c%s%1$c;$s=sprintf($s,39,$e,$s);eval($e);';$s=sprintf($s,39,$e,$s);eval($e);

या, पठनीयता के लिए स्वरूपित:

<?$e='$p = $n = "";
foreach (str_split($s) as $w) {
    $p = $m[$p][] = $w;
}
do {
    echo $n = $m[$n][array_rand($m[$n])];
} while ("\n" != $n);
';$s='<?$e=%c%s%1$c;$s=%1$c%s%1$c;$s=sprintf($s,39,$e,$s);eval($e);';$s=sprintf($s,39,$e,$s);eval($e);

नमूना उत्पादन:

<?p=')ay_r_gecorr_splililen]=$p=$w;

तथा:

<?p=$n=$ntststs$m[$n=$m[ay_r_chondo$n=$ph(s$nt(fitstr_r_geantentr_s('m[$n=$n"!=$p etstsp][$w;d(fililile(s$w)$nt(sphor_str_getrarast(''''m[$n='m[$m';

तथा:

<?p=$who eay_re($n=$n=$nt(')];d(fililileando et($m[]=$pleay_ch(')aray_ren='''))ay_st_r_s($m[$m[asp])ay_co$m[$p $phorentechitr_rean)][$n=$nd("\n"!=$n=$wh(filend('')ay_gen=$ndo$nt_rasp=$n][$p=$whp=$n='m[$n"\n)))))][$w;dorechph(';dorracho$ple_s$w;fil

तथा:

<?ph($n);

PHP धोखा, 117

जिज्ञासु के लिए, यदि हम अपने स्वयं के स्रोत को पढ़कर धोखा देते हैं, तो हम 117 कर सकते हैं:

<?=$p=$n='';foreach(str_split(file('m')[0])as$w)$p=$m[$p][]=$w;do echo$n=$m[$n][array_rand($m[$n])];while("\n"!=$n);

Comments

साइट पर आपका स्वागत है! दुर्भाग्य से हमारे पास कुछ नियम हैं जो इस तरह की चुनौतियों के लिए एक उचित Quine के रूप में गिना जाता है और दुर्भाग्य से अपने स्वयं के स्रोत से पढ़ना निषिद्ध है।

— पोस्ट रॉक गार्फ हंटर

ओह, अच्छा, धन्यवाद। मुझे नियमों की तलाश थी। मुझे इसे संशोधित करना होगा।

— छाता