Zainspirowany github.com/JackToaster/Reassuring-Parable-Generator , z kolei zainspirowany xkcd.com/1263 . Możliwe słowa pochodzą z pliku reassuring.cfg tego repozytorium.

Spójrz na plik reassuring.cfg _{^{(użyj 12-go zatwierdzenia)}} , aby zobaczyć gramatykę, z którą odpowiada wyjście (wyjście jest listą wszystkich ciągów pasujących do gramatyki).

Zadanie: Twój program musi wypisać wszystkie 7968 rozróżniające wielkość liter wiersze dokładnego tekstu zawartego w pastebin pastebin.com/2SNAJ1VH . Kopia pastebinu jest zapisywana w Wayback Machine

Oto próbka 33 linii motywujących z pastebin:

Computers can't enjoy a salad.
Computers can't enjoy a cake.
Computers can't enjoy a ice cream cone.
Computers can't enjoy a meal.
Computers can't enjoy a drink.
Computers can't enjoy a steak.
Computers can't enjoy a chicken dinner.
Computers can't enjoy a piece of cake.
Computers can't enjoy a piece of pie.
Computers can't enjoy a cookie.
Computers can't enjoy a sandwich.
Computers can't taste a salad.
Computers can't taste a cake.
Computers can't taste a ice cream cone.
Computers can't taste a meal.
Computers can't taste a drink.
Computers can't taste a steak.
Computers can't taste a chicken dinner.
Computers can't taste a piece of cake.
Computers can't taste a piece of pie.
Computers can't taste a cookie.
Computers can't taste a sandwich.
Computers can't experience eating a salad.
Computers can't experience eating a cake.
Computers can't experience eating a ice cream cone.
Computers can't experience eating a meal.
Computers can't experience eating a drink.
Computers can't experience eating a steak.
Computers can't experience eating a chicken dinner.
Computers can't experience eating a piece of cake.
Computers can't experience eating a piece of pie.
Computers can't experience eating a cookie.
Computers can't experience eating a sandwich.

Zasady konkursu:

• Dane wyjściowe wierszy można zamówić w dowolny sposób, ale wszystkie 7968 z nich muszą zostać uwzględnione.
• Dane wyjściowe powinny być jako pojedynczy ciąg płaski, a nie jako lista ciągów.
• Twój program nie powinien przyjmować żadnych danych wejściowych ani pustych nieużywanych danych wejściowych.
• Twój program nie może pobierać danych z żadnego źródła online.
• Pojedyncza nowa linia jest opcjonalna.

To jest golf golfowy , więc wygrywa najkrótszy kod.

Zsh , 765 bajtów

To może być pierwsza rzecz, jaką kiedykolwiek napisałem w Zsh, ale ma niewiarygodnie wygodną funkcję konwertowania tablic na rozszerzenia nawiasów klamrowych (choć nie jest to tak wygodne, jak powinno być ... ). Uruchom z zsh -P(liczony jako +1 bajt), który się włącza RC_EXPAND_PARAM.

a=able\ to
b=" be $a"
d=wonderful
i=ing\ a
o=omputer
n="No c$o "
r=ever
p=capable\ of
u=will
w=$u\ n$r
x=experienc
e=(\ {{{enjoy,tast,$x'ing eat'}$i,tast$i\ {delicious,fresh,tasty,refreshing,$d}}\ {salad,cake,'ice cream cone',meal,drink,steak,chicken\ dinner,'piece of '{cake,pie},cookie,sandwich},{understand$i,{enjoy,$x}$i{,\ {beautiful,$d,{inspir,amaz}ing,superb}}}\ {son{net,g},poem,story,play,'piece of music'}}.)
f=(${e:s/cing/ce/:s/sting/ste/:s/ding/d/:s/ying/y})
l=($w won\'t$b {$w,n$r\ $u}{$b,' have the ability to'})
v=($l "won't $r$b")
k=({ca,wo}n\'t $l is{"n't ",\ un}$a)
c=(C$o\s A\ c$o)
printf %s\\n $c\ $k$f C$o's '$v$f $n{can,is\ $a,$u\ $r$b,"is $r going to",{can,$u}\ $r}$f{,} $c\ {is{\ in,"n't "}$p,"cannot $x"e}$e $n{{is,$u\ be}\ $p,"can $x"e}$e

Wypróbuj online!

JavaScript (ES6), 1234 1091 bajtów

To niezła liczba bajtów na początek! Czas na golfa po tym ogromnym sznurku.

f=

_=>(G=`beautiful|wonderful|inspiring|amazing|superb
sonnet|poem|story|play|song${p=`|piece of `}music
cake${p}cake${p}pie|salad|ice cream cone|meal|drink|steak|chicken dinner|cookie|sandwich
delicious|fresh|tasty|refreshing|wonderful
can|is ${a=`able to`}|is ever going to|can ever|will ever${b=` be `+a}|will ever
is ${C=`capable of`}|will be ${C}|can${E=` ${e=`experience`}
${w=`will never`}${b}|${w}${h=` have the ability to|never will`}${h}${b}|won't${b}|${w}|won't`} ever${b}
isn't ${C}|is in${C}|cannot${E}|can't|isn't ${a}|is un${a}`.split`
`.map(l=>l.split`|`),F=S=>[].concat(...S.split`|`.map(s=>eval(s.match(/\d/g).map(n=>`for(f[${n}]of G[${n}])`).join``+`A.push(s.replace(/\\d/g,n=>' '+f[n]));A`,A=[]))),G[9]=F(p=`enjoy a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),G[9]=F(p=`${e=`enjoy`} a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),G[0]=F(p.replace(/([^g])e? (a|e)/g,'$1ing $2')),F(`C${o=`omputer`}s89.|A c${o}89.|C${o}s69.|No c${o}49.|C${o}s70.|A c${o}70.|No c${o}50.|No c${o}49.`).join`
`)

document.write('<pre>'+f())

Mniej golfa:

f=

_=>(

G=`beautiful|wonderful|inspiring|amazing|superb
sonnet|poem|story|play|song${p=`|piece of `}music
cake${p}cake${p}pie|salad|ice cream cone|meal|drink|steak|chicken dinner|cookie|sandwich
delicious|fresh|tasty|refreshing|wonderful
can|is ${a=`able to`}|is ever going to|can ever|will ever${b=` be `+a}|will ever
is ${C=`capable of`}|will be ${C}|can${E=` ${e=`experience`}
${w=`will never`}${b}|${w}${h=` have the ability to|never will`}${h}${b}|won't${b}|${w}|won't`} ever${b}
isn't ${C}|is in${C}|cannot${E}|can't|isn't ${a}|is un${a}`.split`
`.map(l=>l.split`|`),

F=S=>[].concat(...S.split`|`.map(s=>eval(s.match(/\d/g).map(n=>`for(f[${n}]of G[${n}])`).join``+`A.push(s.replace(/\\d/g,n=>' '+f[n]));A`,A=[]))),

G[9]=F(p=`enjoy a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),
G[9]=F(p=`${e=`enjoy`} a2|taste a2|${e} eating a2|taste a32|enjoy a1|${e} a1|enjoy a01|understand a1|${e} a01`),

G[0]=F(p.replace(/([^g])e? (a|e)/g,'$1ing $2')),

F(`C${o=`omputer`}s89.|A c${o}89.|C${o}s69.|No c${o}49.|C${o}s70.|A c${o}70.|No c${o}50.|No c${o}49.`).join`
`

)

document.write('<pre>'+f())

W jaki sposób?

(To zdecydowanie jeden z moich ulubionych golfów wszechczasów!)

Gramatyka jest przechowywana w tablicy G, co daje wynik :

[["beautiful","wonderful","inspiring","amazing","superb"],
 ["sonnet","poem","story","play","song","piece of music"],
 ["salad","cake","ice cream cone","meal","drink","steak","chicken dinner","piece of cake","piece of pie","cookie","sandwich"],
 ["delicious","fresh","tasty","refreshing","wonderful"],
 ["is capable of","can experience","will be capable of"],
 ["can","is able to","is ever going to","can ever","will ever be able to","will ever"],
 ["will never be able to","will never have the ability to","never will have the ability to","never will be able to","won't ever be able to","will never","won't be able to"],
 ["is incapable of","isn't capable of","cannot experience"],
 ["can't","won't","will never","won't be able to","will never be able to","will never have the ability to","never will have the ability to","never will be able to","isn't able to","is unable to"]]

Fjest funkcją, która dzieli ciąg przez separator |i iteruje przez niego. Na razie w porządku.

F=S=>[].concat(...S.split`|`.map( ... )),

Co się dzieje z tą funkcją wewnętrzną?

s=>eval(
    s.match(/\d/g).map(n=>`for(F[${n}]of G[${n}])`).join``+
    `A.push(s.replace(/\\d/g,n=>F[n]));A`,
    A=[]
)

Najpierw inicjalizujemy tablicę A. Następnie znajdujemy wszystkie cyfry w przekazanym ciągu si budujemy podprogram: Za pomocą każdej cyfry ngenerujemy pętlę for- of, która iteruje wpisy G[n](zapisane jako właściwościF , ponieważ funkcje w JavaScript są również obiektami). Pętle są następnie dodawane jeden po drugim.

Na przykład wygenerowany podprogram dla uruchomień s="1 2 3"wygląda następująco:

for(F[1]of G[1])for(F[2]of G[2])for(F[3]of G[3])

Przy każdej iteracji podprogram zastępuje każdą cyfrę sodpowiednią zmianą, zapisaną w pamięci F[n], a wynik jest przekazywany do A. Podprogram jest evaledytowany i Adomyślnie zwracany.

for(F[1]of G[1])for(F[2]of G[2])for(F[3]of G[3])A.push(s.replace(/\d/g,n=>F[n]));A

Używając F, reszta programu po prostu buduje resztę gramatyki na podstawie reguł produkcji, które już istnieją; zamienniki są po prostu zdefiniowane za pomocą jednocyfrowego indeksu w G.

PHP, 877 bajtów

Ach, było fajnie!

for($p="piece of ";$c="AEIMQUY]aeBFJNRVZ^bfQUY]iIMCGKOSWmqunrvoswCGKOSW"[$m++];)foreach([409,T19,"71 eat59",T19delicious,T1916,T19Ty,T19re165,T1914,409,719,40912,40914,409105,409115,40913,understand09,71912,71914,719105,719115,71913]as$i=>$v)foreach($i<8?[salad,cake,"ice cream cone",meal,drink,steak,"chicken dinner",$p.cake,$p.pie,cookie,sandwich]:[sonnet,poem,story,play,song,$p.music]as$u)echo trim(strtr([C17s,"A c17","No c17"][$o=3&$d=ord($c)-65]." ".($o&2?[6,is3,"is 8 go5 to","6 8","2 8 be3","2 8",11=>"is 15","6 7e","2 be 15"]:["6't",$t="won't",$w="2 n8","$t be3","2 n8 be3",$w.$z=" have the ability to","n8 2$z","n8 2 be3","isn't3","is unable to","$t 8 be3","is in15","isn't 15","6not 7e"])[$d/4]." $v",($c>l?[ing,ing]:["",e])+[2=>will," able to",enjoy,ing,can,experienc,ever," a ",inspir,amaz,beautiful,superb,wonderful,"capable of",fresh,omputer,T=>tast]))," $u.
";

Jeśli możesz, możesz spróbować wykopać jeszcze jeden bajt.

bez golfa

while($c="AEIMQUY]aeBFJNRVZ^bfQUY]iIMCGKOSWmqunrvoswCGKOSW"[$p++])
    foreach(["enjoy0 a","tast1 a","experienc1 eating a","tast1 a delicious","tast1 a fresh","tast1 a tasty","tast1 a refreshing","tast1 a wonderful",
    "enjoy0 a","experienc1 a","enjoy0 a beautiful","enjoy0 a wonderful","enjoy0 a inspiring","enjoy0 a amazing","enjoy0 a superb",
    "understand0 a","experienc1 a beautiful","experienc1 a wonderful","experienc1 a inspiring","experienc1 a amazing","experienc1 a superb"]as$i=>$v)
        foreach($i<8
            ?[salad,cake,"ice cream cone",meal,drink,steak,"chicken dinner","piece of cake","piece of pie",cookie,sandwich]
            :[sonnet,poem,story,play,song,"piece of music"]
        as$u)
            echo[Computers,"A computer","No computer"][$o=3&$d=ord($c)-65]," ",
                ($o&2
                    ?[can,"is able to","is ever going to","can ever","will ever be able to","will ever",11=>"is capable of","can experience","will be capable of"]
                    :["can't","won't","will never","won't be able to","will never be able to","will never have the ability to","never will have the ability to","never will be able to","isn't able to","is unable to","won't ever be able to","is incapable of","isn't capable of","cannot experience"]
                )[$d/4]," ",
                strtr($v,$c>l?[ing,ing]:["",e]),
                " $u.\n"
            ;

wyjaśnienie

Wyjście można podzielić na 48 porcji po 166 linii każda. W każdej porcji każda linia zaczyna się od jednej z Computers|A computer|No computernastępującą po niej jedną z 14 negatywnych (dla Computersi A computer) lub 9 pozytywnych (dla No computer) zdolności.
Te fragmenty zakodowałem po 6 bitów każdy (3 różne podmioty -> dolne 2 bity; klawisze dodatnie i ujemne dzielą klucze -> górne 4 bity) i (prawdopodobnie oczywiste) dodałem 65, aby użyć wartości jako kodów ASCII.

W tych częściach jest 8 kombinacji czasowników / przymiotników dla 11 różnych potraw i 13 różnych kombinacji dla 6 różnych sztuk, zawsze w tej samej kolejności; więc można je po prostu zapętlić, używając klucza czasownika / przymiotnika do ustalenia, czy muszę wymienić listę potraw lub napojów w następnej pętli.

Pozostała jedna trudna część: niektóre czapki wymagają formy czasownika gerund; a niektóre czasowniki tracą ew transformacji. Indeks czapki informuje, czy konieczne jest czy nie.
^{(a dzięki kolejności bitów w kodowaniu mogę po prostu użyć znaku ASCII do porównania).}
Ale jak? Po pewnym czasie żonglowania wyrażeniami regularnymi, po prostu stawiam miejsce, w 1którym enależy go zastąpić, ingi miejsce, w 0którym ingnależy go dołączyć i pozwolić na strtrwykonanie zadania.

Oto historia powyższej wersji bez golfisty. (Pakowane 1199 bajtów)

Gra w golfa składała się głównie z 3 kroków:

1. Najczęściej używane sekwencje znaków były przechowywane w zmiennych.
2. strtrzostał rozszerzony na wszystko oprócz tematu w celu przeniesienia zmiennych do strtr.
3. Większość sekwencji przeniesiono ze zmiennych do strtr.

19. słowo tastzastąpiono wielką literą, aby pozbyć się kilku znaków cudzysłowu.

Zastanawiam się, co by się stało, gdybym również zakodował kombinacje czasownika / przymiotnika.
Może mógłbym pokonać Zsh; ale nie jestem pewien, czy zastanawiam się wystarczająco, by spróbować.

Siatkówka, 1249 1192 bajtów

CFs 1 5.¶A cF 1 5.¶C O nG beH 5.¶C O nGKtheJto 5.¶C nG OKtheJto 5.¶C nG O beH 5.¶C won't G beH 5.¶C O nG 5.¶C won't beH 5.¶nNo cF 3 5.¶C 2 6.¶A cF 2 6.¶nNo cF 4 6.¶nNo cF 3 5.
1
can't$%'¶$%`won't$%'¶$%`O nG$%'¶$%`won't beH$%'¶$%`O nG beH$%'¶$%`O nGKtheJto$%'¶$%`nG OKtheJto$%'¶$%`nG O beH$%'¶$%`isn'tH$%'¶$%`is unIto
2
is incapIof$%'¶$%`isn't capIof$%'¶$%`cannot De
3
can$%'¶$%`isH$%'¶$%`is G goQ to$%'¶$%`can G$%'¶$%`O G beH$%'¶$%`O G
4
is capIof$%'¶$%`can De$%'¶$%`O be capIof
5
E a 8$%'¶$%`Le a 8$%'¶$%`De eatQ a 8$%'¶$%`Le a 7 8$%'¶$%`E a 9$%'¶$%`De a 9$%'¶$%`E a B 9$%'¶$%`P a 9$%'¶$%`De a B 9
6
EQ a 8$%'¶$%`LQ a 8$%'¶$%`DQ eatQ a 8$%'¶$%`LQ a 7 8$%'¶$%`EQ a 9$%'¶$%`DQ a 9$%'¶$%`EQ a B 9$%'¶$%`PQ a 9$%'¶$%`DQ a B 9
7
delicious$%'¶$%`fresh$%'¶$%`Ly$%'¶$%`refreshQ$%'¶$%`wonderful
8
salad$%'¶$%`cake$%'¶$%`ice cream cone$%'¶$%`meal$%'¶$%`drink$%'¶$%`steak$%'¶$%`chicken dinner$%'¶$%`Mof cake$%'¶$%`Mof pie$%'¶$%`cookie$%'¶$%`sandwich
9
sonnet$%'¶$%`poem$%'¶$%`story$%'¶$%`play$%'¶$%`song$%'¶$%`Mof music
B
beautiful$%'¶$%`wonderful$%'¶$%`inspirQ$%'¶$%`amazQ$%'¶$%`superb
D
experienc
E
enjoy
F
omputer
G
ever
H
 Ito
I
able 
J
 ability 
K
 have 
L
tast
M
piece 
O
will
P
understand
Q
ing

Wyjście przekracza ograniczenia TIO. Chciałem użyć %`etapów, aby uniknąć wszystkich, $%'¶$%`ale z jakiegoś powodu, który nie robi tego, co chcę. Edycja: Zapisano 57 bajtów dzięki @ fireflame241.

Bubblegum , 23353 bajtów

Tak. Większość z nich nie zmieści się w odpowiedzi, więc ... Zarówno kod, jak i link TIO są w pastach.

Kod (zrzut heksowy kodu)

Łącze TIO (wyjście przekracza ograniczenia TIO)