Cadeia de Markov Quine


17

Um modelo simples de Markov será usado nesta pergunta. Para mais informações sobre cadeias de Markov, consulte http://setosa.io/ev/markov-chains/ .

Pegue uma corda. Neste exemplo, usaremos a palavra:

reader

Agora, para cada caractere, pegue os caracteres que aparecem após cada ocorrência do caractere na sequência. ( ​`^`​representa o início da string e ​`$`​o fim)

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

Agora, começando do início da string, escolha aleatoriamente um dos caracteres no próximo conjunto. Anexe esse personagem e, em seguida, escolha entre os caracteres em seu próximo conjunto e assim sucessivamente até chegar ao final. Aqui estão alguns exemplos de palavras:

r
rereader
rer
readereader

Se um personagem aparecer após outro personagem várias vezes, é mais provável que ele seja escolhido. Por exemplo, em cocoa can, após a c, há dois terços de uma chance de obter uma oe um terço de uma chance de obter uma a.

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

Desafio

Crie um programa que não aceite nenhuma entrada e produza uma sequência aleatória gerada usando uma cadeia de Markov, como acima, em que a entrada na cadeia é a fonte do programa.

  1. O programa deve ter pelo menos dois caracteres, dois dos quais devem ser iguais (para evitar cadeias "chatas" que possuem apenas uma saída)
  2. Você pode modificar o modelo para usar bytes em vez de caracteres, se desejar, mas altere "caracteres" para "bytes" na regra 1
  3. O programa deve gerar seqüências de caracteres aleatoriamente com a frequência esperada em teoria

Isso é , então o programa mais curto vence!


@ mbomb007 toda a informação está na pergunta, o link é apenas extra se você se interessar (Esta é uma implementação muito básico)
Artyer

3
Por que são ^e $entre aspas? pode ficar mais claro tirar aspas ou colocá-las em aspas.
Destrutível Lemon

Respostas:


6

Pip , 64 bytes

Isso foi divertido.

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

<tab> representa um caractere de tabulação literal (0x09 ). Experimente online!

Quão?

TL; DR: sintaxe, repr e eval da cadeia de caracteres de escape.

Para cadeias que precisam conter "caracteres literais , o Pip escapou das cadeias , usando \"como delimitador. Um quine padrão usando cadeias de escape ficaria assim:

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

Isto é: Yank (armazenando como y) uma string que contém "V Y".RPye e a Vela. RPyleva o repr de y, ao qual precedemos a string literal V Y. Finalmente, produza o resultado da avaliação.

A estrutura do quine de Markov é semelhante, exceto que queremos salvar o código em vez de produzi-lo e depois fazer algumas coisas com ele depois. t:V Y\"...\"atribui o resultado da avaliação a t. Dentro do código avaliado, m:"..."atribui uma cadeia de código am qual avaliaremos no final Vm.

ST["t:V Y"RPy";Vm"C9] cria uma lista contendo

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

e converte-o em uma string, que por padrão concatena todos os itens. Esta seção é equivalente ao "V Y".RPyquine original. Como é a última expressão na cadeia de caracteres grande de avaliação, seu valor é o que o Voperador retorna e, portanto, o que é atribuído t.

Assim, após a avaliação e atribuição, té igual ao código completo e mcontém

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

Agora Vmavalia isso como código. Vamos detalhar o que acontece.

                            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

Algumas notas:

  • Terminar o código com uma guia literal foi mais curto do que fazer um teste de expressão regular para "próximo caractere ou final de sequência".
  • O regex que eu usei não funcionará corretamente se houver caracteres duplicados no código; por exemplo, aplicá-lo xxyretornaria apenas xxe não xynas correspondências. Felizmente, no entanto, não há caracteres duplicados neste código, portanto isso não importa.

8

JavaScript, 217 215 bytes

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)

Observe que isso usa uneval, que é suportado apenas pelo Firefox. Amostras de execuções:

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

Como você pode ver, a maioria é sem sentido, mas isso é de se esperar;) O OP criou um JSFiddle que demonstra que a chance de uma saída ser JS sintaticamente válida é de cerca de 6,3%.


Se funções de leitura automática fossem permitidas, este poderia ser 78 bytes do ES6:

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

Muito, muito raramente, isso gera JS sintaticamente válido:

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

Meu favorito dos nomes de funções criados é .splendom()( split+ length+ random)


3
Gostaria de saber qual é a probabilidade de gerar JavaScript válido. (Aviso snipe Nerd)
DanTheMan

2
@ DanTheMan Certamente muito, muito baixo. Apenas a probabilidade de todos os parênteses e colchetes serem equilibrados é incrivelmente baixa. Embora uma vez que eu tenho a.splerength.r(), o que poderia ser válido;)
ETHproductions

11
Pode querer note que este é FF apenas devido ao uso de uneval
Shaun H

11
@ ShaunH Obrigado, esqueci que apenas o FF suporta desigual.
ETHproductions

5
A segunda função de leitura automática não é válida ( meta.codegolf.stackexchange.com/a/4878/48878 "um quine não deve acessar sua própria fonte, direta ou indiretamente.") E @DanTheMan, de acordo com jsfiddle.net / kabkfLak / 1 , a chance deve estar em torno de 6,3%.
Artyer

5

Perl, 103 bytes

Com base no quine padrão e na minha resposta a esta pergunta :

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

Saída de exemplo

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

Da mesma forma que a outra questão, alguns resultados geram Perl válido:

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

mas as chances são um pouco menores, em ~ 2%.


7
Se você me dissesse que o primeiro exemplo era Perl válido, eu acreditaria em você.
Ankh-morpork #

2
@ dohaqatar7 eu não entendi o seu comentário à primeira e achei que você não acreditaria em mim se eu dissesse o código principal era válida Perl ...: D zoitz.com/comics/perl_small.png
Dom Hastings

@ ankh-morpork: é claramente inválido, q{é o início de uma string literal e não há }como fechá-la. O Perl é realmente ruim em executar seqüências aleatórias de bytes (e quando o faz, normalmente é devido a um comentário ou literal de string inicial).

4

Código de máquina do MS-DOS (arquivo .COM), 63 bytes - não concorrente

Não concorrente porque um quine não deve acessar seu próprio código-fonte.

Uma variante de 126 bytes atenderia ao requisito "não acessar seu próprio código-fonte"!

A variante de 63 bytes é assim:

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

Também não tenho certeza sobre a distribuição de probabilidade do gerador aleatório:

O programa usa o fato de que os contadores de relógio e outras informações modificadas por interrupções são armazenadas no segmento 0 para gerar números aleatórios.

Exemplos de saídas geradas são:

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

Convertido em código de montagem, o programa fica assim:

    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:

A não concorrência é reservada para respostas que atendem aos critérios do desafio, mas estão usando um idioma ou recurso mais recente que o desafio. Publique a variante que não lê sua própria fonte ou exclua a resposta.
mbomb007

4

C, 306 328 585 611 615 623 673 707 bytes

Código fonte:

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

Com novas linhas e espaços em branco adicionados para legibilidade / explicação:

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  }

Explicação

Line 01: p[][]mantém a contagem de um caractere após o outro.

Line 02: Xcontém a fonte do programa, com escape %c%s%c.

Line 03: Yconterá a fonte literal do programa. c, j, *aSão variáveis de contagem.

Line 05: Defina Ypara conter o quine.

Line 06: Conte ocorrências de letras em p[][].

Line 07: Imprime o estado atual.

Line 08: Encontre o próximo caractere aleatoriamente, proporcional à contagem em p[][].

Saída de amostra:

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}


11
Você pode adicionar uma versão sem novas linhas e espaços em branco para que possamos verificar a contagem de bytes?
21716 Steven

11
Sim, adicionei a versão de linha única na parte superior.

3

Ruby, 152 bytes

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

Saída de amostra:

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

ou

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

Faz o Quines usando a formatação de string via "s%s", e executa o encadeamento de Markov, pegando todas as fatias de dois caracteres, embaralhando-as e transformando-as em um dicionário Hash, onde, para chaves duplicadas, a última aparência define o valor. Para evitar adicionar lógica extra para o início, rastreio o caractere de saída mais recente usando $/, que é inicializado automaticamente em uma nova linha, e asseguro que as novas linhas sempre sejam seguidas no código pelo 0mesmo caractere com o qual o código começa. No final, eu manipulo o código-fonte para que haja apenas um, !para que sempre terminemos após o estrondo, usando-o <<33para adicioná-lo sem o literal. Isso poderia ser aprimorado usando um caractere de um dígito não imprimível em vez do ASCII 33, mas isso parecia muito irritante.


4
p<<<<<33O operador super-super-super-concat? ;-)
ETHproductions

3
Esse é o operador "waaaay less than".
mbomb007

2
Eu amo as palavras que isso gera! O fato de o primeiro exemplo ser tão preocupante se o objeto Has(s).ears(2)me faz rir!
Dom Hastings

2

Ferrugem, 564 bytes (não 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];}}

Como eu já havia escrito um artigo sobre Rust bem arrumado para outra pergunta, pensei em adaptá-lo para isso, pois parecia bastante simples. Embora o original fosse pequeno, para isso, fiz muito pouca tentativa de minimizar o tamanho. Aqui está uma versão expandida para explicar o que está acontecendo:

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

Saída de amostra 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];}{}

Saída de amostra 2:

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

2

Python 2, 211 bytes

Emite o resultado para 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

Experimente online

Saída de amostra:

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 explicação:

  • Este programa usa o s='s=%r;print s%%s';print s%sformato quine. Eu crio uma string s, que conterá o programa inteiro.
  • A sequência Xcontém o procedimento para executar recursivamente.
  • O procedimento cria a sequência de saída o, que será impressa parastderr atingir o final da cadeia de Markov.
  • O final da cadeia é representado pela cadeia $$, usando dois caracteres para que o programa funcione para todas as cadeias. Eu poderia ter usado um personagem que não está no meu programa chr(0), mas acho que é mais.
  • O caractere escolhido em que cada execução é colocada c, que (junto com o) é inicializado no primeiro caractere do programa.
  • A lista de caracteres que seguem cada ocorrência de escolha cna sequência t(a variável que contém o quine do código fonte) é a qqual será escolhida para a próxima seleção de c.

1

PHP, 144 135 130 120 272 220 212 bytes

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

Ou formatado para facilitar a leitura:

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

Saída de amostra:

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

Trapaça do PHP, 117

Para os curiosos, se enganarmos lendo nossa própria fonte, podemos fazer 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);

Bem vindo ao site! Infelizmente, temos algumas regras sobre o que conta como um Quine adequado para desafios como esse e, infelizmente, a leitura de sua própria fonte é proibida.
Post Rock Garf Hunter

Oh, bom obrigado. Eu estava procurando as regras. Vou ter que revisar isso.
Umbrella
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.