In questa domanda verrà utilizzato un semplice modello Markov. Per ulteriori informazioni sulle catene Markov, vedere http://setosa.io/ev/markov-chains/ .

Prendi una corda. Per questo esempio, useremo la parola:

reader

Ora, per ogni personaggio, prendi i caratteri che compaiono dopo ogni occorrenza del carattere nella stringa. ( ​`^`​rappresenta l'inizio della stringa e ​`$`​rappresenta la fine)

`^` -> {'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'}

Ora, a partire dall'inizio della stringa, scegli casualmente uno dei caratteri del set successivo. Aggiungi questo personaggio e poi scegli tra i personaggi nel suo prossimo set, e così via fino ad arrivare alla fine. Ecco alcune parole di esempio:

r
rereader
rer
readereader

Se un personaggio appare dopo un altro personaggio più volte, è più probabile che venga scelto. Ad esempio, in cocoa can, dopo a c, ci sono due terzi della possibilità di ottenere un oe un terzo della possibilità di ottenere un a.

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

Sfida

Crea un programma che non accetta input e genera una stringa casuale generata utilizzando una catena di Markov, come sopra, in cui l'input della catena è l'origine del programma.

1. Il programma deve avere almeno due caratteri, due dei quali devono essere uguali (per evitare catene "noiose" che hanno un solo output)
2. Se lo desideri, puoi modificare il modello in modo da utilizzare i byte anziché i caratteri, ma modifica i "caratteri" in "byte" nella regola 1
3. Il programma dovrebbe produrre stringhe casualmente con la frequenza prevista in teoria

Questo è code-golf , quindi vince il programma più corto!

Pip , 64 byte

È stato divertente.

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

<tab>rappresenta un carattere di tabulazione letterale ( 0x09). Provalo online!

Come?

TL; DR: sintassi della stringa di escape, repr ed eval.

Per le stringhe che devono contenere "caratteri letterali , Pip ha evitato le stringhe , usando \"come delimitatore. Un quine standard che utilizza stringhe di escape sarebbe simile al seguente:

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

Cioè: Yank (memorizzando come y) una stringa contenente "V Y".RPyed e Val esso. RPyprende il repr diy , al quale anteponiamo la stringa letterale V Y. Infine, genera il risultato di valutazione.

La struttura del Markov Quine è simile, tranne per il fatto che vogliamo salvare il codice invece di emetterlo e poi fare alcune cose con esso in seguito. t:V Y\"...\"assegna il risultato di valutazione a t. All'interno del codice di valutazione, m:"..."assegna una stringa di codice am cui valuteremo alla fine Vm.

ST["t:V Y"RPy";Vm"C9] crea un elenco contenente

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

e lo converte in una stringa, che per impostazione predefinita concatena tutti gli elementi. Questa sezione è equivalente a "V Y".RPyquella originale. Poiché è l'ultima espressione nella grande stringa di valutazione, il suo valore è ciò che l' Voperatore restituisce e quindi ciò a cui viene assegnato t.

Quindi, dopo la valutazione e l'assegnazione, tè uguale al codice completo e mcontiene

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

Ora lo Vmvaluta come codice. Analizziamo cosa succede.

                            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

Un paio di note:

• La fine del codice con una scheda letterale è stata più breve rispetto al test regex per "carattere successivo o fine della stringa".
• Il regex che ho usato non funziona correttamente se ci sono caratteri doppi nel codice; per esempio, applicarlo a xxysarebbe restituito solo xxe non xynelle partite. Fortunatamente, tuttavia, non ci sono caratteri doppi in questo codice, quindi non importa.

JavaScript, 217 215 byte

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)

Si noti che questo utilizza uneval, che è supportato solo da Firefox. Esecuzioni campione:

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()

Come puoi vedere, è per lo più incomprensibile, ma è prevedibile;) L'OP ha creato un JSFiddle che dimostra che la probabilità che un output sia JS sintatticamente valido è di circa il 6,3%.

Se le funzioni di auto-lettura fossero consentite, potrebbero essere 78 byte di ES6:

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

Molto, molto raramente, questo produce JS sintatticamente valido:

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

Il mio preferito dei nomi delle funzioni che ha creato è .splendom()( split+ length+ random)

Perl, 103 byte

Sulla base del quine standard e della mia risposta a questa domanda :

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

Esempio di output

$_=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

Analogamente all'altra domanda, alcuni risultati generano un Perl valido:

$_=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

ma le probabilità sono leggermente inferiori, a ~ 2%.

Codice macchina MS-DOS (file .COM), 63 byte - non competitivo

Non competitivo perché un quine non deve accedere al proprio codice sorgente.

Una variante a 126 byte soddisferebbe il requisito "non accedere al proprio codice sorgente"!

La variante a 63 byte si presenta così:

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

Non sono inoltre sicuro della distribuzione di probabilità del generatore casuale:

Il programma utilizza il fatto che i contatori di clock e altre informazioni modificate dagli interrupt sono memorizzati nel segmento 0 per generare numeri casuali.

Esempi di output generati sono:

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

Convertito in codice assembly il programma si presenta così:

    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:

C, 306 328 585 611 615 623 673 707 byte

Codice sorgente:

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());}

Con newline e spazi bianchi aggiunti per leggibilità / spiegazione:

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  }

Spiegazione

Line 01: p[][]contiene i conteggi di un personaggio dopo l'altro.

Line 02: Xcontiene l'origine del programma, con escape %c%s%c.

Line 03: Yconterrà la fonte letterale del programma. c, j, *aSono variabili di conteggio.

Line 05: Impostato Yper contenere il quine.

Line 06: Conta le occorrenze delle lettere in p[][].

Line 07: Stampa lo stato corrente.

Line 08: Trova il personaggio successivo in modo casuale, proporzionale ai conteggi in p[][].

Uscita campione:

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}

Rubino, 152 byte

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][$/])==?!

Uscita campione:

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

o

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=?!

Effettua la query utilizzando la formattazione delle stringhe tramite "s%s"e esegue il concatenamento di Markov prendendo tutte le sezioni di due caratteri, mescolandole e trasformandole in un dizionario hash, dove per le chiavi duplicate l'ultimo aspetto definisce il valore. Per evitare di aggiungere ulteriore logica all'inizio, tengo traccia dell'ultimo carattere di output utilizzato $/, che viene inizializzato automaticamente su una nuova riga, e assicuro che le nuove righe siano sempre seguite nel codice dallo 0stesso carattere con cui inizia il codice. Per finire, manipolo il codice sorgente in modo che ce ne sia solo uno, !così finiamo sempre dopo il botto, usando <<33per aggiungerlo senza il valore letterale. Questo potrebbe essere ulteriormente risolto usando un carattere non stampabile a una cifra anziché ASCII 33, ma sembrava troppo fastidioso.

Ruggine, 564 byte (non competitivo)

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];}}

Dato che avevo già scritto un quine Rust abbastanza pulito per un'altra domanda, ho pensato di adattarlo per questo, dal momento che sembrava abbastanza semplice. Sebbene l'originale fosse piccolo, per questo ho fatto pochissimo tentativo di ridurre al minimo le dimensioni. Ecco una versione estesa per spiegare cosa sta succedendo:

// 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.
    }
}

Uscita campione 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];}{}

Uscita campione 2:

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

Python 2, 211 byte

Invia il risultato a 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

Provalo online

Uscita campione:

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

Breve spiegazione:

• Questo programma utilizza il s='s=%r;print s%%s';print s%sformato Quine. Creo una stringa s, che conterrà l'intero programma.
• La stringa X contiene la procedura per l'esecuzione ricorsiva.
• La procedura crea la stringa di output o, che verrà stampata sustderr raggiungimento della fine della catena Markov.
• La fine della catena è rappresentata dalla stringa $$, usando due caratteri in modo che il programma funzioni per tutte le stringhe. Avrei potuto usare un personaggio non presente nel mio programmachr(0) , ma penso che sia più lungo.
• Il personaggio scelto per ogni esecuzione viene inserito c, che (insieme ao ) viene inizializzato al primo carattere del programma.
• L'elenco dei caratteri che seguono ogni occorrenza scelta cnella stringa t(la variabile che contiene il quine del codice sorgente) è q, che sarà scelto per la successiva selezione di c.

PHP, 144 135 130 120 272 220 212 byte

<?$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);

Oppure, formattato per la leggibilità:

<?$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);

Uscita campione:

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

e:

<?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';

e:

<?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

e:

<?ph($n);

PHP Cheating, 117

Per i curiosi, se imbrogliamo leggendo la nostra fonte, possiamo fare 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);