Esse desafio é inspirado em uma série de livros infantis de Fiona Watt e Rachel Wells, que eu tenho gostado recentemente com minha filha.

Em cada livro, um mouse (ilustrado, mas não parte do texto) reclama que uma sucessão de 5 coisas do mesmo tipo não é o que faz. Depois, confirma isso declarando que algum componente da coisa não tem a propriedade que espera.

Na sexta vez em que é perguntado, o mouse encontra o que procura e fica satisfeito porque possui a propriedade esperada.

Aqui está o texto de um exemplo típico:

That's not my bunny, its tail is too fluffy.
That's not my bunny, its paws are too rough.
That's not my bunny, its tail is too woolly.
That's not my bunny, its eyes are too shiny.
That's not my bunny, its nose is too wrinkled.
That's my bunny! Its ears are so soft.

Agora, a maioria das pessoas da programação perceberia que esse é um método muito algorítmico de produzir algum texto. Por ser um processo tão claro, poderemos reproduzir isso escrevendo algum código.

Vamos começar com três coleções de palavras:

things = ["dinosaur", "lamb", "princess", "reindeer", "train"]
parts = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
properties = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

• Primeiro, decidimos que tipo de coisa iremos descrever.
• Então, cinco vezes, geraremos a linha "Essa não é a minha coisa, a sua parte é demais.
• Finalmente, geramos a linha "Essa é a minha coisa! Sua parte é tão propriedade!

O desafio

• Gere o texto de uma história "Essa não é a minha ...".
• Ele não deve reproduzir consistentemente o mesmo texto.
• É código de golfe, então tente fazê-lo no menor número de bytes.
• Use qualquer idioma que desejar.
• O espaço em branco não importa, mas deve haver um caractere de nova linha entre as linhas.
• As listas de palavras-fonte não fazem parte da sua resposta (no TIO elas podem ser adicionadas ao cabeçalho).
• Você pode renomear as listas de palavras-fonte.
• A saída pode ser enviada para um terminal ou texto gerado em um objeto.
• Inclua um link para um intérprete online.
• Ignorar plurais ", seus chifres são" está bom.
• Não precisa fazer sentido. Se o funil da sua princesa estiver fofo demais, basta dizer.

Saída de amostra:

That's not my train, its engine is too rusty.
That's not my train, its hooves is too thick.
That's not my train, its sash is too fuzzy.
That's not my train, its tail is too velvety.
That's not my train, its horns is too glittery.
That's my train! Its hooves is so hairy.

Feliz golfe!

05AB1E , 63 bytes

ΩU6F€Ω`XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

Experimente online.

Versão de 68 bytes que não gera peças nem propriedades duplicadas:

ΩUε.r6£}øεXª`N5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

Experimente online.

Ambos os programas assumem que a lista de itens é a primeira entrada e uma lista contendo a lista de partes e a lista de propriedades é a segunda entrada.

Explicação:

Ω            # Pop and push a random element of the things-list
 U           # Pop and store it in variable `X`
  6F         # Loop 6 times:
    €Ω       #  Get a random element from both the parts and properties list
      `      #  Push them to the stack
       X     #  And also push variable `X`
             #  (the order on the stack is now: property, part, thing)
    N5Qi     #  If it's the last iteration:
        “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ 
            '#   Push dictionary string "that's my ÿ! its ÿ is so ÿ."
       ë     #  Else:
        “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“
            '#   Push dictionary string "that's not my ÿ, its ÿ is too ÿ."
             #  (where the `ÿ` are automatically replaced with the words on the stack)
       }.ª   #  After the if-else: sentence-capitalize the strings
             #  (so the "That's " as well as the "! Its")
          ,  #  And output it with trailing newline


ΩU           # Pop and store a random thing in variable `X`
  ε          # Map the list of lists of parts/properties to:
   .r        #  Shuffle the list
     6£      #  And leave the first six elements
  }ø         # After the map: zip/transpose to create pairs of part & property
    ε        # Foreach over the pairs:
     `XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,
             #  And the rest of the code is the same as above

Veja esta dica 05AB1E (seção Como usar o dicionário? ) Para entender por que“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ é "that's my ÿ! its ÿ is so ÿ."e “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“é "that's not my ÿ, its ÿ is too ÿ.".

Python 3 , 149 bytes

lambda a,*l:shuffle(a)or["That's "+s%(a[0],*map(choice,l))for s in["not my %s, its %s is too %s."]*5+["my %s! Its %s is so %s."]]
from random import*

Experimente online!

-9 bytes graças a movatica

Carvão , 72 bytes

≔‽θθＦ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»That's my θ! Its ‽η is so ‽ζ.

Experimente online! Link é a versão detalhada do código. Espera que as matrizes de coisas, peças e propriedades para estar nas variáveis θ, ηe ζ, o que é mais facilmente dispostas, proporcionando-lhes na entrada, em vez do cabeçalho. Explicação:

≔‽θθ

Escolha uma coisa aleatória.

Ｆ⁵«That's not my θ, its ‽η is too ‽ζ.⸿»

Imprima cinco frases negativas.

That's my θ! Its ‽η is so ‽ζ.

Imprima a frase positiva.

Japt v2.0a0 -R, 73 bytes

ö
6Æ`Tt's {`not `pT=Y<5}my {+`!,`gT} {73dT*H}ts {Vö}  {`tÑ?`ë2!T} {Wö}.

Toma as três listas como U, VeW . De qualquer forma, essas são as variáveis ​​de entrada padrão; basta colocar as três listas na seção de entrada.

Tente

ö                         Saves the random object in variable U
6Æ                        Range [0..6), and map each to the following string
`That's                   The string "That's " plus
{`not `pT=Y<5}            "not " if the index is less than 5 (and store that in variable T), else ""
my                        Literal "my " plus
{+`!,`gT}                 U plus ',' if T, else '!'
{73dT*H}ts                "its " if T, else "Its "
{Vö}                      Random item from V
is                         
{`tsooo`ë2!T}             "too" if T, else "so"
{Wö}.                     Random item from V, plus a period

PowerShell , 147 bytes

Este programa principal não repetirá nenhuma parte ou propriedade em uma execução e possui uma randomização razoável.

$t=$l|Random
$a=$a|Random -c 6
$r=$r|Random -c 6
0..4|%{"That's not my $t, its $($a[$_]) is too "+$r[$_]}
"That's my $t! Its $($a[5]) is so "+$r[5]

Experimente online!

Escrever get-randomtantas vezes custa tantos caracteres! No entanto, a menos que você esteja disposto a permitir que partes e propriedades sejam repetidas, não vejo mais como diminuir isso no PowerShell. A menos que você mova os 3 primeiros tubos de linha para o final das 3 linhas de atribuição no cabeçalho. Ter algo como

# Header
$l = ("dinosaur", "lamb", "princess", "reindeer", "train")|Get-Random
$a = ("back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows")|sort{Get-Random}
$r = ("bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly")|sort{Get-Random}

# Main
(1..5)|%{echo("That's not my $t, its "+$a[$_]+" is too "+$r[$_])}
"That's my $t! Its "+$a[6]+" is so "+$r[6]

Mas isso parece estar enganando, e ainda não supera a resposta de Neil.

Edit: Obrigado pelas dicas Matt, e obrigado AdmBorkBork por aprimorá-las, remover os 3 conjuntos de get-texto reduziu para 159 bytes e, em seguida, um pouco mais de golfe do Adm reduziu para 147. O código que eu pensava que permitia duplicatas e declarações contraditórias foram 144 caracteres após a aplicação das mesmas dicas de golfe.

function n{(random 18)+1}
$t=$l[(n)%5]
0..4|%{"That's not my $t, its $($a[(n)]) is too "+$r[(n)]}
"That's my $t! Its $($a[$(n)]) is so "+$r[(n)]

Experimente online!

No entanto, ele não apenas tem a tendência de dizer a mesma coisa várias vezes, mas também exige que suas entradas tenham o mesmo número de elementos. Acredito que o gerador de números pseudo-aleatórios que está sendo usado depende muito do relógio, e chamadas rápidas e repetidas para ele frequentemente podem resultar no mesmo resultado. Em seguida, ele tem a condição de que só use a lista inteira se todas as listas tiverem o mesmo comprimento. Com apenas 3 a 5 caracteres e com tantas advertências, prefiro o código no início deste post.

Geléia , 72 bytes

XWWẋ6;X€}⁶pʋ€s5“ʠĖµʋb⁵J¥\¢wBD®-Ƥd(CḤ!²kT“Ø!1ẆÑ⁹ṁṾƤṛḄėÄṂMƓṾṖ¿O*½»Ỵ€¤żⱮ"ẎY

Experimente online!

JavaScript, 129

(a,b,c)=>(z='',a.forEach((f,i)=>z+=`That's ${q=i!=5?"not ":""}my ${f}${q?", i":"! I"}ts ${b[i]} is ${q?"to":"s"}o ${c[i]}.\n`),z)

entrada é três matrizes, retorna string

Ruby , 128 bytes

->a,*l{t=a.sample;6.times{|i|puts"That's#{' not'if i<5} my #{t}#{i<5?', i':'! I'}ts %s is #{i<5?'to':?s}o %s."%l.map(&:sample)}}

Experimente online!

C # , 204 203 bytes

()=>{int a(int x)=>new Random().Next(x);var j=t[a(5)];string s()=>$"That's not my {j}, its {p[a(25)]} is too {o[a(19)]}.\n";return s()+s()+s()+s()+s()+$"That's my {j}! Its {p[a(25)]} is so {o[a(19)]}.";};

É a minha primeira resposta neste site, por isso espero que funcione bem. Ele também precisa dessas três coisas, mas, de acordo com a pergunta, elas não contam:

   var t = new[] { "dinosaur", "lamb", "princess", "reindeer", "train" };
   var p = new[] {"back", "bells", "body", "bows", "crown", "dress", "ears",
          "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
          "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
          "tiara", "wheels", "windows" };
   var o = new[] {"bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
          "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
          "soft", "sparkly", "squashy", "thick", "velvety", "woolly"};

Experimente online!

Menos um byte graças a Sok.

APL (Dyalog Unicode) , 117 bytes ^SBCS

↑('That''s not my ',(t←T⊃⍨?5),', its ')∘,¨P[5?25],¨' is too '∘,¨V[5?19]
'That''s my ',t,'! Its',P[?25],'is so',V[?19]

Experimente online!

?N gera um índice aleatório entre os primeiros N índices.

M?N gera M índices aleatórios (sem substituição) entre os primeiros N índices.

, é concatenação

t←T⊃⍨... escolhe uma coisa aleatória e chama t para reutilização na última linha.

∘,¨ concatena a string da esquerda para cada string da direita.

,¨ concatena cada string à esquerda para cada string à direita.

↑ altera a lista de cadeias de caracteres em uma matriz de caracteres para que ela seja impressa corretamente.

Pitão , 88 78 76 bytes

JONj_ms.ic"That's
 my 

ts 
 is 
o 
."b[?d" not"kJ?d", i""! I"OG?d\s"to"OH)6

Experimente online!

O código apresentado acima requer o seguinte cabeçalho:

=N["dinosaur""lamb""princess""reindeer""train")=G["back""bells""body""bows""crown""dress""ears""engine""fan""flippers""funnel""hooves""horns""neck""nose""roof""sash""side""spines""spots""tail""teeth""tiara""wheels""windows")=H["bumpy""fluffy""furry""fuzzy""glittery""glossy""hairy""red""rough""rusty""shiny""silky""slippery""soft""sparkly""squashy""thick""velvety""woolly")

Há um pequeno problema ao usar o recurso 'Cabeçalho' no TIO com Pyth, pois parece que o TIO une os blocos de código nas novas linhas, e as novas linhas são significativas no Pyth. Aqui está um link para o mesmo código usando o bloco 'Header', com uma linha de lixo eletrônico na saída.

JONj_ms.ic"That's¶ my ¶¶ts ¶ is ¶o ¶."b[?d" not"kJ?d", i""! I"OG?d"to"\sOH)6   Newlines replaced with ¶
                                                                               Implicit: k="", b=newline
                                                                               From header: N=things, G=parts, H=properties
JON                                                                            Choose a random element from N, store in J
     m                                                                     6   Map [0-6), as d, using:
                                        ?d" not"k                                If d is truthy (i.e. not 0), yield " not", else ""
                                                 J                               J (the chosen thing)
                                                  ?d", i""! I"                   ", i" if d else "! I"
                                                              OG                 Random element from G
                                                                ?d"to"\s         "to" if d else "s"
                                                                        OH       Random element from H
                                       [                                  )      Wrap the previous 6 results in an array
         c"That's¶ my ¶¶ts ¶ is ¶o ¶."b                                          Split the template string on newlines
       .i                                                                        Interleave the template string elements with the previous list
      s                                                                          Concatenate
    _                                                                          Reverse lines
   j                                                                           Join on newlines, implicit print

Edit: Reescreva para golf 10 bytes, versão anterior: J+" my "ONV5%"That's not%s, its %s is too %s."[JOGOH;%"That's%s! Its %s is so %s."[JOGOH

Perl 5.10, 127 bytes

Corra com perl -M5.010 -f filename.pl.

my @t = qw(dinosaur lamb princess reindeer train);
my @r = qw(back bells body bows crown dress ears engine fan flippers funnel
           hooves horns neck nose roof sash side spines spots tail teeth tiara
           wheels windows);
my @p = qw(bumpy fluffy furry fuzzy glittery glossy hairy red rough rusty shiny
           silky slippery soft sparkly squashy thick velvety woolly);

sub r{rand@_}$a=" my $t[r@t]";say"That's not$a, its $r[r@r] is too $p[r@p]."for(1..5);say"That's$a! Its $r[r@r] is so $p[r@p]."

JavaScript ES6, 149 (+15?) Bytes

a = ["dinosaur", "lamb", "princess", "reindeer", "train"]
b = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
c = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

// r=x=>x[parseInt(Math.random()*x.length)] 164 for better random on fast pc

r=x=>x[new Date%x.length]
s=r(a)
g=j=>console.log(`That's ${j?`not my ${s}, its ${r(b)} is to`:`my ${s}! Its ${r(b)} is s`}o ${r(c)}.`)
a.map(g) 
g()

Arquivo em lote, 434 424 + 7 bytes

Executado via cmd/q/c.

Código não contado

set a=dinosaur lamb princess reindeer train
set b=back bells body bows crown dress ears engine fan flippers funnel hoobes horns neck nose roof sash side spines spots tail teeth tiara wheels windows
set c=bumpy fluffy furry fizzy glittery glossy hair red rough rusty shiny silky slippery soft sparkly squashy thick velvety woolly

Código contado

set q=random
set m=set/ar=1+%%%q%%%%%%%
call %m%5
for /f "tokens=%r%" %%x in ("%a%")do set x=%%x
:a
set/ad+=1
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.
if %d% neq 5 goto a
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's my %x%! Its %y% is so %%z.

Vou enfrentar alguns desafios que você deve enfrentar e explicar / justificar o que fiz para que outros possam melhorar.

Escolha um elemento aleatório de uma matriz
que fiz isso gerando um número aleatório entre 1e nonde nestá a quantidade de elementos nessa matriz. Em seguida, usei esse número aleatório como o token para capturar cada forloop ( tokens=%r%). Porque eu fiz dessa maneira, não consegui aninhar essesfor loops, pois tokens=!r!não estava funcionando para mim (com expansão atrasada). Isso economizaria alguns bytes, pois eliminaria a necessidade de salvar os tokens como variáveis ​​( set x=%%x).

A geração aleatória de números
m é minha macro de geração aleatória de números. Fazer dessa maneira economiza 32 bytes, como em set/ar=%random%%%n+1todas as linhas. Você pode semi-trapacear e decidir esses tokens ye zdeve ser o mesmo elemento:

call %m%19
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.

Isso, embora ainda retenha alguma aleatoriedade, excluiria os 6 elementos finais do c . Isso economizaria no mínimo 20 bytes, mas não acho que isso seja verdade para os requisitos da operação.

Melhorias teóricas
Passei um bom tempo tentando fazer esse "pseudo-código" funcionar, enquanto ainda salvava bytes:

set 1-5=echo That's not my %x%, its %y% is too %%z.
set 6=echo That's my %x%! Its %y% is so %%z.
...
set/ad+=1
for /f "tokens=%r%" %%z in ("%c%")do call %%d%%

Infelizmente, a configuração para isso está demorando muitos bytes para ser lucrativa (precisa ser implementada em <144 bytes), mas não posso deixar de pensar que adicionar as últimas 4 linhas de código é supérfluo e irregular.

tinta , 119 bytes

~a=LIST_RANDOM(a)
-(l)That's{l<6: not} my {a}{l<6:, i|! I}ts {LIST_RANDOM(b)} is {l<6:to|s}o {LIST_RANDOM(c)}
{l<6:->l}

Com as listas definidas como

LIST a=(dinosaur),(lamb),(princess),(reindeer),(train)
LIST b=(back),(bells),(body),(bows),(crown),(dress),(ears),(engine),(fan),(flippers),(funnel),(hooves),(horns),(neck),(nose),(roof),(sash),(side),(spines),(spots),(tail),(teeth),(tiara),(wheels),(windows)
LIST c=(bumpy),(fluffy),(furry),(fuzzy),(glittery),(glossy),(hairy),(red),(rough),(rusty),(shiny),(silky),(slippery),(soft),(sparkly),(squashy),(thick),(velvety),(woolly)

Experimente online!

Embora, dependendo do que conta como lista, existem outras abordagens. Se uma lista puder ser uma função que retorna aleatoriamente um item da lista, a abordagem a seguir será de apenas 91 bytes:

~temp t=u()
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {p()} is {l<6:to|s}o {q()}
{l<6:->l}

(com as "listas" definidas da seguinte forma)

==function u
~return "{~dinosaur|lamb|princess|reindeer|train}"
==function p
~return "{~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows}"
==function q
~return " {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}."

Experimente online!

Há também a seguinte abordagem.

~temp t="{~dinosaur|lamb|princess|reindeer|train}"
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows} is {l<6:to|s}o {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}
{l<6:->l}

Experimente online!

Essa solução tem 389 bytes, mas se os literais aleatórios (que neste cenário não podem ser realmente movidos) contam como definições de lista e podem ser excluídos da contagem de bytes, isso cai para 80 bytes.

Bash + awk, 209 bytes

T=$(shuf $1|head -1)
join <(sed "s/.*/$T\t&/" $2) <(sed "s/.*/$T\t&/" $3)|shuf|awk 'NR<6{printf "That'\''s not my %s, its %s is too %s.\n",$1,$2,$3}NR==6{printf "That'\''s my %s! Its %s is so %s.\n",$1,$2,$3}'

Experimente online!

Aceita entradas como things parts properties onde cada um é um arquivo com um item por linha do tipo desejado.

Essa é uma abordagem centrada em arquivos. Pode tentar uma abordagem centrada na matriz posteriormente para ver se ela pode ser aprimorada.

Python 3, 130 bytes

Tomando seus requisitos literalmente e tendo retornos de carro com um byte cada:

y=0
def x():
    global y
    y=1-y 
    print(("That's not my lamb, it's "+b[0:1][y]+" is too red\n")*5+"That's my lamb! Its fan is so red")