Las computadoras nunca probarán una galleta refrescante

11

Inspirado en github.com/JackToaster/Reassuring-Parable-Generator , inspirado a su vez en xkcd.com/1263 . Las posibles palabras se derivan del reassuring.cfg de ese repositorio.

Se recomienda echar un vistazo a reassuring.cfg (use el 12º commit) para ver la gramática que coincide con la salida (La salida es una lista de todas las cadenas que coinciden con la gramática).

Tarea: Su programa debe mostrar todas las 7968 líneas que distinguen entre mayúsculas y minúsculas del texto exacto contenido en pastebin pastebin.com/2SNAJ1VH . Se guarda una copia del pastebin en Wayback Machine

Aquí hay una muestra de 33 líneas motivadoras del 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.

Reglas de desafío:

  • La salida de las líneas se puede ordenar de la forma que desee, pero todas las 7968 deben estar incluidas.
  • La salida debe ser como una sola cadena plana, no como una lista de cadenas.
  • Su programa no debe aceptar ninguna entrada o una entrada vacía sin usar.
  • Es posible que su programa no obtenga datos de ninguna fuente en línea.
  • Una nueva línea final es opcional.

Este es el , por lo que gana el código más corto.

fireflame241
fuente
Relacionado
James
44
No computer {can} {action}.se repite dos veces y Computers {cannot_present}produce frases como "Las computadoras son incapaces de". ¿Intencional?
darrylyeo
Cualquier error aparente en el pastebin debe incluirse en la salida de todos los programas (no podemos cambiar las especificaciones de los programas anteriores). El reassuring.cfg es solo una gramática de muestra que es al menos bastante precisa.
fireflame241
Para competir en este Id, tengo que escribir un analizador para la entrada solo para enumerar los únicos lol.
Urna de pulpo mágico
Como referencia, el enlace TIO a la solución Bubblegum es demasiado largo para responder. El código fuente es 23270 bytes.
musicman523

Respuestas:

7

Zsh , 765 bytes

Esto puede ser lo primero que he escrito en zsh, pero tiene la característica increíblemente conveniente de poder convertir matrices para expansiones de llaves (aunque no es tan conveniente como debería ser ... ). Corre conzsh -P (contado como +1 byte), que se activa 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

Pruébalo en línea!

Anders Kaseorg
fuente
4

JavaScript (ES6), 1234 1091 bytes

¡Es un buen conteo de bytes para comenzar! Es hora de jugar golf en esa enorme cuerda.

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

Menos golfizado:

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


¿Cómo?

(¡Este es, con mucho, uno de mis campos de golf más favoritos de todos los tiempos!)

La gramática se almacena en la matriz G, que se evalúa a esto:

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

Fes una función que divide una cadena por el delimitador |y la itera. Hasta aquí todo bien.

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

¿Qué está pasando con esta función interna?

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

Primero inicializamos una matriz A. Entonces nos encontramos con todos los dígitos en la cadena pasada sy construimos un subprograma: El uso de cada dígito n, generamos un for- ofbucle que itera a través de las entradas G[n](almacenados como propiedades F, ya que las funciones en JavaScript son también objetos). Los bucles se agregan uno tras otro.

Por ejemplo, el subprograma generado para s="1 2 3"comienza así:

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

En cada iteración, el subprograma reemplaza cada dígito scon su reemplazo correspondiente, almacenado F[n], y el resultado se empuja a A. El subprograma se evaledita y Ase devuelve implícitamente.

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

Utilizando F, el resto del programa simplemente construye el resto de la gramática a partir de las reglas de producción que ya existen; Los reemplazos se definen simplemente por un índice de un solo dígito en G.

Darrylyeo
fuente
¡Buena esa! Pero esto parece bloquearse si no se llama a la función f. Por lo tanto, f=debe agregarse al recuento de bytes.
Arnauld
(Creo que esto se puede solucionar reutilizando en Flugar de f).
Arnauld
@Arnauld Buena captura.
darrylyeo
4

PHP, 877 bytes

Ah, eso fue divertido!

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

Si puede, intente desenterrar un byte más.

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

explicación

La salida se puede dividir en 48 trozos de 166 líneas cada uno. Dentro de cada fragmento, cada línea comienza con una de Computers|A computer|No computerseguida de una de 14 capacidades negativas (para Computersy A computer) o 9 positivas (para No computer).
Codifiqué estos fragmentos a 6 bits cada uno (3 sujetos diferentes -> 2 bits inferiores; las mayúsculas positivas y negativas comparten claves -> 4 bits superiores), y (probablemente obvio) agregué 65 para usar los valores como códigos ASCII.

Dentro de estos fragmentos, 8 combinaciones verbo / adjetivo para 11 alimentos diferentes y 13 combinaciones diferentes para 6 artes diferentes, siempre en el mismo orden; para que simplemente se puedan recorrer en bucle, usando la tecla verbo / adjetivo para determinar si tengo que enumerar alimentos o bebidas en el siguiente ciclo.

Quedaba una parte difícil: algunas de las mayúsculas requieren la forma gerundia del verbo; y algunos de los verbos pierden un een la transformación. El índice de límite indica si es necesario o no.
(y gracias al orden de los bits en la codificación, simplemente puedo usar el carácter ASCII para la comparación).
¿Pero cómo? Después de hacer malabarismos con expresiones regulares por un tiempo, simplemente coloco un lugar 1donde edebe ser reemplazado ingy un lugar 0donde ingdebe agregarse y dejar que strtrhaga el trabajo.

Esa es la historia de la versión anterior sin golf. (1199 bytes empaquetados)


El golf consistió principalmente en 3 pasos:

  1. La mayoría de las secuencias de caracteres utilizadas se almacenaron en variables.
  2. strtrse extendió a todo excepto al sujeto para mover variables a strtr.
  3. La mayoría de las secuencias se movieron de variables a strtr.

La palabra 19 tast, fue reemplazada por una letra mayúscula para deshacerse de un par de comillas.


Me pregunto qué pasaría si también codificara las combinaciones verbo / adjetivo.
Tal vez podría vencer a Zsh; pero no estoy seguro si me pregunto lo suficiente como para intentarlo.

Titus
fuente
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

La salida excede las limitaciones de TIO. Quería usar %`etapas para evitar todo $%'¶$%`pero, por alguna razón, eso no hace lo que quiero. Editar: Guardado 57 bytes gracias a @ fireflame241.

Neil
fuente
Todavía hay espacio para la compresión: inge 'Ito' se usan varias veces. Cada llamada a 1, 2y 5 está precedida y seguida por un espacio, por lo que se pueden poner en la sustitución. Del mismo modo, 6y 7siempre van seguidos de un punto. 3parece que solo se usa una vez.
fireflame241
@ fireflame241 No puedo modificar los dígitos porque necesitan repetir su sustitución varias veces, ¡pero gracias por las otras ideas!
Neil
0

Chicle , 23353 bytes

Sip. La mayor parte no cabe en una respuesta, así que ... Tanto el código como el enlace TIO están en pastas.

Código (un hexdump del código)

Enlace TIO (la salida excede las limitaciones de TIO)

totalmente humano
fuente