Computer werden niemals einen erfrischenden Keks probieren

11

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 , also gewinnt der kürzeste Code.

fireflame241
quelle
Verwandte
James
4
No computer {can} {action}.wird zweimal wiederholt und Computers {cannot_present}erzeugt Sätze wie "Computer sind nicht in der Lage". Absichtlich?
Darrylyeo
Alle offensichtlichen Fehler im Pastebin müssen für alle Programme in der Ausgabe enthalten sein (wir können die Spezifikationen für frühere Programme nicht ändern). Die beruhigende.cfg ist nur eine Beispielgrammatik, die zumindest ziemlich genau ist.
fireflame241
Um an dieser ID teilnehmen zu können, muss ein Parser für die Eingabe geschrieben werden, um die eindeutigen lol aufzulisten.
Magic Octopus Urn
Als Referenz ist die TIO- Verknüpfung zur Bubblegum-Lösung zu lang, um eine Antwort einzugeben. Der Quellcode ist 23270 Bytes.
musicman523

Antworten:

7

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!

Anders Kaseorg
quelle
4

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.

darrylyeo
quelle
Schön! Dies scheint jedoch zum Absturz zu kommen, wenn die Funktion nicht aufgerufen wird f. Sollte f=also zur Byteanzahl hinzugefügt werden.
Arnauld
(Ich denke, dies kann durch Wiederverwendung Fstatt behoben werden f.)
Arnauld
@Arnauld Guter Fang.
Darrylyeo
4

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.

Titus
quelle
1

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.

Neil
quelle
Es gibt noch etwas Raum für Komprimierung: ingund "Ito" werden jeweils mehrmals verwendet. Jedem Aufruf von 1, 2und 5 vor und nach einem Leerzeichen können diese in die Substitution eingefügt werden. Ebenso 6und 7werden immer von einem Punkt gefolgt. 3scheint nur einmal verwendet zu werden.
fireflame241
@ fireflame241 Ich kann die Ziffern nicht ändern, da sie ihre Ersetzung mehrmals wiederholen müssen, aber danke für die anderen Ideen!
Neil
0

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)

total menschlich
quelle