У цьому питанні буде використана проста модель Маркова. Для отримання додаткової інформації про Маркові ланцюги див. 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. Програма повинна виводити рядки випадковим чином із очікуваною частотою теоретично

Це код-гольф , тому найкоротша програма виграє!

Піп , 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 уникнув рядки , використовуючи \"як роздільник. Стандартна лайка, що використовує рядки, що увійшли, виглядала б так:

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

Тобто: Yank (зберігання як y) рядок, що містить "V Y".RPyта e Val it. RPyприймає репр y, до якого ми додаємо буквальний рядок V Y. Нарешті, виведіть результат eval.

Структура квітки Маркова схожа, за винятком того, що ми хочемо зберегти код, а не виводити його, а потім виконувати з ним деякі речі. 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в оригінальній квінці. Оскільки це останній вираз у великій рядку 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би повертався лише, xxа не xyв матчах. На щастя, однак у цьому коді немає подвоєних символів, тому це не має значення.

JavaScript, 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, що підтримується лише Firefox. Проби:

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

Як бачите, це здебільшого гнучкість, але цього можна очікувати;) ОП створила 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)

Perl, 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 байти - неконкурентоспроможний

Не змагається, тому що квітка не має доступу до власного вихідного коду.

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: Встановити, 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}

Рубін, 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", і чи робить це Марков ланцюжок, беручи всі двосимвольні фрагменти, перетасовуючи їх і перетворюючи їх у словник Hash, де для дублюючих ключів останній вигляд визначає значення. Щоб уникнути додавання додаткової логіки для початку, я відстежую останній символ виводу за допомогою $/, який автоматично ініціалізується на новий рядок, і гарантую, що нові рядки завжди дотримуються в коді 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];}}

Оскільки я вже написав доволі акуратну Квінку Руста для іншого питання, я подумав, що адаптую це для цього, оскільки це здалося досить простим. Хоча оригіналу було мало, але для цього я зробив дуже малу спробу мінімізувати розмір. Ось розширена версія, щоб пояснити, що відбувається:

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

Python 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формат quine. Я створюю рядок s, який буде містити всю програму.
• Рядок Xмістить процедуру виконання рекурсивно.
• Процедура будує вихідний рядок o, який буде надрукований stderrпісля досягнення кінця ланцюга Маркова.
• Кінець ланцюга представлений рядком $$, використовуючи два символи, щоб програма працювала для всіх рядків. Я міг би використовувати символу не у своїй програмі, як chr(0), але я думаю, що це довше.
• Символ, обраний кожним виконанням, розміщується у c, який (разом з o) ініціалізується на перший символ програми.
• Список символів, які слідкують за кожним випадком вибору cу рядку t(змінна, що містить кінь вихідного коду), є 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);