Inspiriert von github.com/JackToaster/Reassuring-Parable-Generator , wiederum inspiriert von xkcd.com/1263 . Die möglichen Wörter werden aus der beruhigenden.cfg dieses Repositorys abgeleitet.

Ein Blick auf die beruhigende.cfg _{^{(verwenden Sie das 12. Commit)}} wird empfohlen, um die Grammatik zu sehen, mit der die Ausgabe übereinstimmt (Die Ausgabe ist eine Liste aller Zeichenfolgen, die mit der Grammatik übereinstimmen).

Aufgabe: Ihr Programm muss alle 7968 Zeilen mit Groß- und Kleinschreibung des genauen Textes ausgeben, der im Pastebin pastebin.com/2SNAJ1VH enthalten ist . Eine Kopie des Pastebins wird in der Wayback-Maschine gespeichert

Hier ist ein Beispiel von 33 motivierenden Zeilen aus dem 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.

Herausforderungsregeln:

• Die Zeilenausgabe kann beliebig geordnet werden, alle 7968 müssen jedoch enthalten sein.
• Die Ausgabe sollte als einzelne flache Zeichenfolge erfolgen, nicht als Liste von Zeichenfolgen.
• Ihr Programm sollte keine Eingabe oder eine leere nicht verwendete Eingabe akzeptieren.
• Ihr Programm ruft möglicherweise keine Daten aus einer Online-Quelle ab.
• Eine einzelne nachfolgende Newline ist optional.

Dies ist Code-Golf , also gewinnt der kürzeste Code.

Zsh , 765 Bytes

Dies ist vielleicht das erste, was ich jemals in zsh geschrieben habe, aber es hat die unglaublich praktische Funktion, Arrays in Klammererweiterungen konvertieren zu können (obwohl es nicht so praktisch ist, wie es sein sollte ... ). Führen Sie mit zsh -P(gezählt als +1 Byte) aus, was sich einschaltet 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

Probieren Sie es online aus!

JavaScript (ES6), 1234 1091 Byte

Das ist eine schöne Anzahl von Bytes, um zu beginnen! Zeit, diese riesige Saite zu spielen.

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

Weniger Golf:

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

Wie?

(Dies ist bei weitem einer meiner Lieblingsgolfplätze aller Zeiten!)

Die Grammatik wird im Array gespeichert G, das Folgendes ergibt :

[["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"]]

Fist eine Funktion, die eine Zeichenfolge durch das Trennzeichen |aufteilt und durchläuft. So weit, ist es gut.

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

Was ist nun mit dieser inneren Funktion los?

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=[]
)

Zuerst initialisieren wir ein Array A. Dann finden wir alle Ziffern in der übergebenen Zeichenfolge sund erstellen ein Unterprogramm: Mit jeder Ziffer ngenerieren wir eine for- ofSchleife, die die Einträge in durchläuft G[n](gespeichert als Eigenschaften von F, da Funktionen in JavaScript auch Objekte sind). Die Schleifen werden dann nacheinander angehängt.

Das generierte Unterprogramm für s="1 2 3"startet beispielsweise wie folgt:

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

Bei jeder Iteration ersetzt das Unterprogramm jede Ziffer sdurch die entsprechende Ersetzung, die in gespeichert ist F[n], und das Ergebnis wird an weitergeleitet A. Das Unterprogramm wird evalbearbeitet und Aimplizit zurückgegeben.

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

Mit Fbaut der Rest des Programms einfach den Rest der Grammatik aus den bereits vorhandenen Produktionsregeln auf. Ersetzungen werden einfach durch einen einstelligen Index in definiert G.

PHP, 877 Bytes

Ah das hat Spaß gemacht!

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.
";

Fühlen Sie sich frei, ein weiteres Byte zu graben, wenn Sie können.

ungolfed

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

Erläuterung

Die Ausgabe kann auf 48 Blöcke mit jeweils 166 Zeilen aufgeteilt werden. Innerhalb jedes Blocks beginnt jede Zeile mit einer von Computers|A computer|No computer14 negativen (für Computersund A computer) oder 9 positiven (für No computer) Fähigkeiten.
Ich habe diese Chunks auf jeweils 6 Bit codiert (3 verschiedene Subjekte -> untere 2 Bits; die positiven und negativen Kappen teilen sich die Schlüssel -> obere 4 Bits) und (wahrscheinlich offensichtlich) 65 hinzugefügt, um die Werte als ASCII-Codes zu verwenden.

Innerhalb dieser Stücke 8 Verb / Adjektiv-Kombinationen für 11 verschiedene Lebensmittel und 13 verschiedene Kombinationen für 6 verschiedene Künste, immer in derselben Reihenfolge; So können sie einfach durchgeschleift werden, indem der Verb- / Adjektivschlüssel verwendet wird, um zu bestimmen, ob ich Lebensmittel oder Getränke in der nächsten Schleife auflisten muss.

Ein kniffliger Teil blieb: Einige der Kappen erfordern die gerundete Form des Verbs; und einige der Verben verlieren ein ein der Transformation. Der Cap-Index gibt an, ob dies erforderlich ist oder nicht.
^{(und dank der Reihenfolge der Bits in der Codierung kann ich einfach das ASCII-Zeichen für den Vergleich verwenden).}
Aber wie? Nach dem Jonglieren mit regulären Ausdrücken für eine Weile, habe ich einfach ein , 1wo die emit ausgetauscht werden muss ingund ein , 0wo ingangehängt werden muss und lassen Sie strtrdie Arbeit machen.

Das ist die Geschichte der oben genannten Version ohne Wolf. (1199 Bytes gepackt)

Das Golfen bestand hauptsächlich aus 3 Schritten:

1. Die am häufigsten verwendeten Zeichenfolgen wurden in Variablen gespeichert.
2. strtrwurde auf alles außer dem Betreff erweitert, um Variablen zu verschieben strtr.
3. Die meisten Sequenzen wurden von Variablen nach verschoben strtr.

Das 19. Wort tastwurde durch einen Großbuchstaben ersetzt, um ein paar Anführungszeichen zu entfernen.

Ich frage mich, was passieren würde, wenn ich auch die Verb / Adjektiv-Kombinationen codieren würde.
Vielleicht könnte ich Zsh schlagen; aber ich bin mir nicht sicher, ob ich mich genug wundere, um es zu versuchen.

Retina, 1249 1192 Bytes

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

Die Ausgabe überschreitet die TIO-Beschränkungen. Ich wollte %`Stufen verwenden, um all das zu vermeiden, $%'¶$%`aber aus irgendeinem Grund macht das nicht das, was ich will. Bearbeiten: 57 Bytes dank @ fireflame241 gespeichert.

Bubblegum , 23353 Bytes

Jep. Das meiste davon passt nicht in eine Antwort, also ... Sowohl der Code als auch der TIO-Link sind in Pasten.

Code (ein Hexdump des Codes)

TIO-Verbindung (die Ausgabe überschreitet die Einschränkungen von TIO)