이 질문에는 간단한 Markov 모델이 사용됩니다. Markov Chains에 대한 자세한 내용은 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,을 얻기의 기회의 2/3이 o과를 얻기의 1 분의 기회 a.

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

도전

입력을받지 않고 위와 같이 Markov Chain을 사용하여 생성 된 임의의 문자열을 출력하는 프로그램을 작성하십시오. 여기서 체인의 입력은 프로그램의 소스입니다.

1. 프로그램에는 최소한 두 개의 문자가 있어야하며 두 문자는 동일해야합니다 (한 개의 출력 만있는 "보링"체인을 방지하려면)
2. 원하는 경우 문자 대신 바이트를 사용하도록 모델을 수정할 수 있지만 규칙 1에서 "문자"를 "바이트"로 변경하십시오.
3. 프로그램은 이론적으로 예상되는 빈도로 문자열을 무작위로 출력해야합니다.

이것은 code-golf 이므로 가장 짧은 프로그램이 승리합니다!

핍 , 64 바이트

재미있었습니다.

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

<tab>리터럴 탭 문자 ( 0x09)를 나타냅니다 . 온라인으로 사용해보십시오!

어떻게?

TL; DR : 이스케이프 된 문자열 구문, repr 및 eval.

리터럴 "문자 를 포함해야하는 문자열의 경우 Pip는 구분 기호로 사용하여 string 을 이스케이프했습니다\" . 이스케이프 된 문자열을 사용하는 표준 quine은 다음과 같습니다.

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

즉 : 포함 하고 있는 문자열을 Yank (로 저장 y) 합니다. 리터럴 문자열 앞에 붙인 repr을 사용 합니다 . 마지막으로 평가 결과를 출력합니다."V Y".RPyVRPyyV Y

Markov quine의 구조는 코드를 출력하는 대신 저장 한 다음 나중에 일부 작업을 수행한다는 점을 제외하면 비슷합니다. t:V Y\"...\"평가 결과를에 할당합니다 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원본 quine 과 동일합니다 . 큰 eval 문자열의 마지막 표현식이므로 값은 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반환 만됩니다 . 그러나이 코드에는 문자가 두 배가되지 않으므로 문제가되지 않습니다.xxxy

자바 스크립트, 217215 바이트

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

보시다시피, 대부분 횡설수설이지만 예상됩니다.) OP는 JSFiddle 을 생성 하여 출력이 구문 상 유효한 JS 일 가능성이 약 6.3 %임을 보여줍니다.

자체 읽기 기능이 허용 된 경우 78 바이트의 ES6 일 수 있습니다.

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

매우 드물게 이것은 구문 상 유효한 JS를 출력합니다.

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)

펄, 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

다른 질문과 마찬가지로 일부 결과는 유효한 Perl을 생성합니다.

$_=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 %로 약간 더 낮습니다.

MS-DOS 머신 코드 (.COM 파일), 63 바이트-비경쟁

quine이 자체 소스 코드에 액세스해서는 안되므로 경쟁이되지 않습니다.

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:

C, 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: Yquine을 포함하도록 설정 합니다.

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}

루비, 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=?!

를 통해 문자열 형식화를 사용하는 Quines "s%s"는 모든 두 문자 슬라이스를 가져 와서 셔플 링하고 해시 사전으로 전환하여 Markov 체인을 수행합니다. 중복 키의 경우 마지막 모양이 값을 정의합니다. 처음에 추가 논리를 추가하지 않기 위해 $/개행으로 자동 초기화되는을 사용하여 가장 최근에 출력 된 문자를 추적 하고 코드에서 개행이 0코드에서 시작하는 동일한 문자 로 항상 뒤에 오는지 확인 하십시오. 결국, 나는 소스 코드를 조작하여 하나만 !있으므로 <<33리터럴없이 추가하기 위해 항상 뱅 후에 끝납니다 . ASCII 33 대신 인쇄 할 수없는 한 자리 문자를 사용하여 더 골프를 칠 수는 있지만 너무 성가신 것 같습니다.

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

나는 이미 다른 질문에 대해 꽤 깔끔한 Rust quine을 작성 했으므로 간단하게 보였으므로 이것을 적용 할 것이라고 생각했습니다. 그러나 원본은 작지만 크기를 최소화하려고 거의 시도하지 않았습니다. 진행 상황을 설명하는 확장 버전은 다음과 같습니다.

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

파이썬 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%squine 형식을 사용 합니다. s전체 프로그램을 포함 하는 string을 만듭니다 .
• 문자열 X에는 재귀 적으로 실행되는 프로 시저가 포함됩니다.
• 이 절차는 출력 문자열을 빌드 하며 Markov 체인의 끝에 도달하면 o인쇄됩니다 stderr.
• 체인의 끝은 $$프로그램이 모든 문자열에 대해 작동하도록 두 문자를 사용하여 문자열로 표시됩니다 . 와 같은 프로그램에없는 문자를 사용할 수 chr(0)있었지만 더 길다고 생각합니다.
• 각 실행에서 선택한 문자는에 배치되며 c(와 함께 o) 프로그램의 첫 번째 문자로 초기화됩니다.
• 선택의 각각의 발생에 따라 문자 목록 c문자열에서 t(변수가 소스 코드의 quine을 잡고)이다 q의 다음 선택에서 선택됩니다 c.

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