Os computadores nunca provarão um cookie refrescante

11

Inspirado em github.com/JackToaster/Reassuring-Parable-Generator , por sua vez, inspirado em xkcd.com/1263 . As palavras possíveis são derivadas do reassuring.cfg desse repositório.

É recomendável dar uma olhada no reassuring.cfg (use a 12ª confirmação) para ver a gramática correspondente à saída (a saída é uma lista de todas as sequências correspondentes à gramática).

Tarefa: Seu programa deve gerar todas as 7968 linhas com distinção entre maiúsculas e minúsculas do texto exato contido em pastebin pastebin.com/2SNAJ1VH . Uma cópia do pastebin é salva no Wayback Machine

Aqui está uma amostra de 33 linhas motivadoras da pastabin:

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.

Regras do desafio:

  • A saída das linhas pode ser solicitada da maneira que você desejar, mas todos os 7968 deles devem ser incluídos.
  • A saída deve ser como uma única cadeia plana, não como uma lista de cadeias.
  • Seu programa não deve aceitar nenhuma entrada ou uma entrada não utilizada vazia.
  • Seu programa não pode buscar dados de nenhuma fonte online.
  • Uma única nova linha à direita é opcional.

Isso é , então o código mais curto vence.

fireflame241
fonte
Relacionado
James
4
No computer {can} {action}.é repetido duas vezes e Computers {cannot_present}produz frases como "Computadores não podem". Intencional?
darrylyeo
Quaisquer erros aparentes no pastebin devem ser incluídos na saída de todos os programas (não podemos alterar as especificações dos programas anteriores). O reassuring.cfg é apenas uma amostra gramatical que é pelo menos bastante precisa.
fireflame241
Para competir neste ID, tem que escrever um analisador para a entrada apenas para listar os únicos lol.
Magic Octopus Urn
Para referência, o link do TIO para a solução Bubblegum é muito longo para responder. O código fonte é 23270 bytes.
musicman523

Respostas:

7

Zsh , 765 bytes

Esta pode ser a primeira coisa que eu já escrevi no zsh, mas tem o recurso incrivelmente conveniente de poder converter matrizes para preparar expansões (embora não seja tão conveniente quanto deveria ser ... ). Execute com zsh -P(contado como +1 byte), que é ativado 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

Experimente online!

Anders Kaseorg
fonte
4

JavaScript (ES6), 1234 1091 bytes

É uma boa contagem de bytes para começar! Hora de jogar golfe nessa enorme corda.

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 golfe:

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


Quão?

(Este é de longe um dos meus golfe mais favoritos de todos os tempos!)

A gramática é armazenada na matriz G, que avalia isso:

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

Fé uma função que divide uma string pelo delimitador |e itera através dela. Por enquanto, tudo bem.

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

Agora, o que está acontecendo com essa função 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=[]
)

Primeiro, inicializamos uma matriz A. Em seguida, encontramos todos os dígitos na string passada se construímos um subprograma: Usando cada dígito n, geramos um loop for- ofque itera pelas entradas em G[n](armazenadas como propriedades de F, já que funções em JavaScript também são objetos). Os loops são anexados um após o outro.

Por exemplo, o subprograma gerado para s="1 2 3"inicia assim:

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

Em cada iteração, o subprograma substitui cada dígito spor sua substituição correspondente, armazenada F[n]e o resultado é enviado para A. O subprograma é evaled e Aé retornado implicitamente.

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

Usando F, o restante do programa simplesmente cria o restante da gramática a partir das regras de produção que já existem; substituições são simplesmente definidas por um índice de um dígito em G.

darrylyeo
fonte
Agradável! Mas isso parece travar se a função não for chamada f. Portanto, f=deve ser adicionado à contagem de bytes.
Arnauld
(Eu acho que isso pode ser corrigido através da reutilização F, em vez de f.)
Arnauld
@ Arnauld Boa captura.
darrylyeo
4

PHP, 877 bytes

Ah, isso foi 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.
";

Sinta-se à vontade para tentar desenterrar mais um byte, se puder.

destroçado

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

explicação

A saída pode ser dividida em 48 blocos de 166 linhas cada. Dentro de cada pedaço, cada linha começa com um dos Computers|A computer|No computerseguidos por um dos 14 recursos negativos (para Computerse A computer) ou 9 positivos (para No computer).
Codifiquei esses pedaços para 6 bits cada (3 assuntos diferentes -> menos 2 bits; os caps positivos e negativos compartilham chaves -> 4 bits superiores) e (provavelmente óbvio) adicionei 65 para usar os valores como códigos ASCII.

Dentro desses blocos, 8 combinações de verbo / adjetivo para 11 alimentos diferentes e 13 combinações diferentes para 6 artes diferentes, sempre na mesma ordem; para que eles possam simplesmente ser repetidos, usando a tecla do verbo / adjetivo para determinar se preciso listar alimentos ou bebidas no próximo loop.

Uma parte complicada permaneceu: algumas das letras maiúsculas requerem a forma gerúndria do verbo; e alguns dos verbos perdem um ena transformação. O índice de limite informa se é necessário ou não.
(e, graças à ordem dos bits na codificação, posso simplesmente usar o caractere ASCII para a comparação).
Mas como? Depois de fazer malabarismos com expressões regulares por um tempo, eu simplesmente coloco um local 1onde o eitem deve ser substituído inge um 0local ingque deve ser anexado e deixo strtrfazer o trabalho.

Essa é a história da versão não destruída acima. (1199 bytes compactados)


O golfe consistiu principalmente em 3 etapas:

  1. As seqüências de caracteres mais usadas foram armazenadas em variáveis.
  2. strtrfoi estendido a tudo, exceto o assunto, a fim de mover variáveis ​​para strtr.
  3. A maioria das seqüências foi movida das variáveis ​​para strtr.

A 19a palavra, tastfoi substituída por uma letra maiúscula para se livrar de algumas aspas.


Eu me pergunto o que aconteceria se eu também codificasse as combinações de verbo / adjetivo.
Talvez eu pudesse vencer Zsh; mas não tenho certeza se me pergunto o suficiente para tentar.

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

A saída excede as limitações do TIO. Eu queria usar %`estágios para evitar tudo, $%'¶$%`mas por algum motivo isso não faz o que eu quero. Editar: salvou 57 bytes graças a @ fireflame241.

Neil
fonte
Ainda há espaço para compactação: inge o `Ito` é usado várias vezes. Cada chamada para 1, 2e 5 é precedido e seguido por um espaço, por isso estes podem ser colocados na substituição. Da mesma forma, 6e 7sempre são seguidos por um período. 3parece ser usado apenas uma vez.
amigos estão dizendo sobre fireflame
@ fireflame241 Não consigo modificar os dígitos porque eles precisam repetir sua substituição várias vezes, mas obrigado pelas outras idéias!
Neil
0

Bubblegum , 23353 bytes

Sim. A maior parte não cabe em uma resposta, então ... Tanto o código quanto o link TIO estão em pastas.

Código (um hexdump do código)

Link TIO (a saída excede as limitações do TIO)

totalmente humano
fonte