Inspiré par github.com/JackToaster/Reassuring-Parable-Generator , à son tour inspiré par xkcd.com/1263 . Les mots possibles sont dérivés du fichier rassurant.cfg de ce référentiel.

Il est suggéré de jeter un œil au fichier rassurant.cfg _{^{(utilisez le 12ème commit)}} pour voir la grammaire à laquelle la sortie correspond (la sortie est une liste de toutes les chaînes correspondant à la grammaire).

Tâche: votre programme doit générer toutes les 7968 lignes sensibles à la casse du texte exact contenu dans le pastebin pastebin.com/2SNAJ1VH . Une copie du pastebin est enregistrée dans la Wayback Machine

Voici un échantillon de 33 lignes motivantes de la boîte à pâte:

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.

Règles du défi:

• La sortie des lignes peut être commandée comme vous le souhaitez, mais toutes les 7968 doivent être incluses.
• La sortie doit être une seule chaîne plate, pas une liste de chaînes.
• Votre programme ne doit accepter aucune entrée ou une entrée vide non utilisée.
• Votre programme peut ne pas récupérer les données d'une source en ligne.
• Une seule nouvelle ligne de fin est facultative.

C'est le code-golf , donc le code le plus court l'emporte.

Zsh , 765 octets

C'est peut-être la première chose que j'ai jamais écrite en zsh, mais elle a la fonctionnalité incroyablement pratique de pouvoir convertir des tableaux en extensions d'accolade (bien que ce ne soit pas aussi pratique qu'il devrait l'être… ). Exécuter avec zsh -P(compté comme +1 octet), qui s'allume 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

Essayez-le en ligne!

JavaScript (ES6), 1234 1091 octets

C'est un bon nombre d'octets pour commencer! Il est temps de jouer au golf sur cette énorme chaîne.

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

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

Comment?

(C'est de loin l'un de mes golfs les plus préférés de tous les temps!)

La grammaire est stockée dans le tableau G, ce qui correspond à ceci:

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

Fest une fonction qui divise une chaîne par le délimiteur |et l'itère. Jusqu'ici tout va bien.

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

Maintenant, que se passe-t-il avec cette fonction intérieure?

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

D'abord, nous initialisons un tableau A. Ensuite, nous trouvons tous les chiffres dans la chaîne passée set construisons un sous-programme: En utilisant chaque chiffre n, nous générons une boucle for- ofqui itère à travers les entrées dans G[n](stockée en tant que propriétés de F, car les fonctions en JavaScript sont également des objets). Les boucles sont ensuite ajoutées l'une après l'autre.

Par exemple, le sous-programme généré pour s="1 2 3"démarre comme ceci:

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

À chaque itération, le sous-programme remplace chaque chiffre entrant spar son remplacement correspondant, stocké dans F[n], et le résultat est poussé vers A. Le sous-programme est evalédité et Aest implicitement renvoyé.

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

En utilisant F, le reste du programme construit simplement le reste de la grammaire à partir des règles de production qui existent déjà; les remplacements sont simplement définis par un index à un chiffre dans G.

PHP, 877 octets

Ah c'était amusant!

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

N'hésitez pas à essayer de déterrer un octet de plus si vous le pouvez.

non golfé

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

explication

La sortie peut être divisée en 48 morceaux de 166 lignes chacun. Dans chaque bloc, chaque ligne commence par l'une des Computers|A computer|No computersuivies par l'une des 14 capacités négatives (pour Computerset A computer) ou 9 positives (pour No computer).
J'ai codé ces morceaux en 6 bits chacun (3 sujets différents -> 2 bits inférieurs; les touches de partage des majuscules positives et négatives -> 4 bits supérieurs) et (probablement évident) ajouté 65 pour utiliser les valeurs comme codes ASCII.

Au sein de ces morceaux, 8 combinaisons verbe / adjectif pour 11 aliments différents et 13 combinaisons différentes pour 6 arts différents, toujours dans le même ordre; afin qu'ils puissent simplement être bouclés, en utilisant la clé verbe / adjectif pour déterminer si je dois lister les aliments ou les boissons dans la boucle suivante.

Il restait une partie délicate: certaines des majuscules nécessitent la forme gérondive du verbe; et certains des verbes perdent un edans la transformation. L'index de cap indique si cela est nécessaire ou non.
^{(et grâce à l'ordre des bits dans l'encodage je peux simplement utiliser le caractère ASCII pour la comparaison).}
Mais comment? Après avoir jonglé avec des regex pendant un certain temps, j'ai simplement mis un 1où le edoit être remplacé inget un 0où ingdoit être ajouté et laisser strtrfaire le travail.

C'est l'histoire de la version non golfée ci-dessus. (1199 octets compressés)

Le golf consistait principalement en 3 étapes:

1. La plupart des séquences de caractères utilisées ont été stockées dans des variables.
2. strtra été étendu à tout sauf au sujet afin de déplacer les variables vers strtr.
3. La plupart des séquences ont été déplacées des variables vers strtr.

Le 19ème mot, a tastété remplacé par une majuscule pour se débarrasser de quelques guillemets.

Je me demande ce qui se passerait si j'encodais également les combinaisons verbe / adjectif.
Peut-être que je pourrais battre Zsh; mais je ne sais pas si je me demande assez pour essayer.

Rétine, 1249 1192 octets

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

La sortie dépasse les limitations TIO. Je voulais utiliser des %`étapes pour éviter tout cela, $%'¶$%`mais pour une raison quelconque, cela ne fait pas ce que je veux. Edit: 57 octets enregistrés grâce à @ fireflame241.

Bubblegum , 23353 octets

Ouaip. La plupart d'entre eux ne rentrent pas dans une réponse, alors ... Le code et le lien TIO sont tous deux dans des pâtes.

Code (un hexdump du code)

Lien TIO (la sortie dépasse les limites de TIO)