Questa sfida è ispirata a una serie di libri per bambini di Fiona Watt e Rachel Wells, che mi sono divertito di recente con mia figlia.

In ogni libro un topo (illustrato, ma non parte del testo) si lamenta che una successione di 5 cose dello stesso tipo non fanno al caso suo. Quindi esegue il backup dichiarando che alcuni componenti della cosa non hanno la proprietà che si aspetta.

Alla sesta volta, il mouse trova la sua cosa ed è contento perché ha la proprietà prevista.

Ecco il testo di un esempio tipico:

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.

Ora, la maggior parte dei programmatori si renderebbe conto che questo è un metodo molto algoritmico per produrre del testo. Poiché è un processo così chiaro, dovremmo essere in grado di riprodurlo scrivendo del codice.

Cominciamo con tre raccolte di parole:

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

• Innanzitutto, decidiamo quale tipo di cosa descriveremo.
• Quindi 5 volte, genereremo la riga "Questa non è la mia [cosa], la sua [parte] è troppo [proprietà].
• Infine, generiamo la riga "Questa è la mia [cosa]! La sua [parte] è così [proprietà]!

La sfida

• Genera il testo di una storia "Questa non è la mia ...".
• Non deve riprodurre in modo coerente lo stesso testo.
• È il golf del codice, quindi prova a farlo nel minor numero di byte.
• Usa qualsiasi lingua per favore.
• Lo spazio bianco non ha importanza, ma deve esserci un carattere di nuova riga tra le righe.
• Gli elenchi di parole sorgente non fanno parte della tua risposta (in TIO possono essere aggiunti all'intestazione).
• È possibile rinominare gli elenchi delle parole sorgente.
• L'output può essere emesso su un terminale o il testo generato in un oggetto.
• Si prega di includere un collegamento a un interprete online.
• Ignora i plurali, "le sue corna" va bene.
• Non ha senso. Se l'imbuto della tua principessa è troppo soffice, dillo e basta.

Uscita campione:

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.

Buon golf!

05AB1E , 63 byte

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

Provalo online.

Versione a 68 byte che non genera parti duplicate né proprietà:

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

Provalo online.

Entrambi i programmi presuppongono che l'elenco delle cose sia il primo input e un elenco contenente l'elenco delle parti e l'elenco delle proprietà sia il secondo input.

Spiegazione:

Ω            # 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

Vedi questo mio suggerimento 05AB1E (sezione Come usare il dizionario? ) Per capire perché “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“è "that's my ÿ! its ÿ is so ÿ."ed “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“è "that's not my ÿ, its ÿ is too ÿ.".

Python 3 , 149 byte

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*

Provalo online!

-9 byte grazie a movatica

Carbone , 72 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Si attende che le matrici di cose, le parti e le proprietà di essere in variabili θ, ηe ζ, che è più facilmente disposto fornendo loro nell'input anziché l'intestazione. Spiegazione:

≔‽θθ

Scegli una cosa a caso.

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

Stampa cinque frasi negative.

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

Stampa la frase positiva.

Japt v2.0a0 -R, 73 byte

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

Prende le tre liste come U, Ve W. Queste sono comunque le variabili di input predefinite, quindi basta inserire i tre elenchi nella sezione input.

Provalo

ö                         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 byte

Questo programma principale non ripeterà alcuna parte o proprietà in una corsa e ha una randomizzazione ragionevole.

$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]

Provalo online!

Scrivere get-randomcosì tante volte costa così tanti personaggi! Tuttavia, a meno che non si desideri lasciare che parti e proprietà vengano ripetute, non riesco più a vedere un modo per ridurlo ulteriormente in PowerShell. A meno che non si sposti i primi 3 tubi di linea alla fine delle 3 linee di assegnazione nell'intestazione. Per avere qualcosa di simile

# 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]

Ma sembra che stia tradendo, e comunque non batte la risposta di Neil.

Modifica: Grazie per i suggerimenti Matt, e grazie AdmBorkBork per averli sviluppati, la rimozione dei 3 set di get-testo lo ha ridotto a 159 byte, quindi un po 'più di golf da Adm lo ha ridotto a 147. Il codice a cui stavo pensando che consentiva duplicati e dichiarazioni contraddittorie erano 144 caratteri dopo aver applicato gli stessi consigli sul golf.

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

Provalo online!

Tuttavia, non solo ha la tendenza a dire la stessa cosa più volte, ma richiede praticamente che i tuoi input abbiano lo stesso numero di elementi. Credo che il generatore di numeri pseudo casuali utilizzato sia fortemente dipendente dall'orologio e che le chiamate ripetute rapide ad esso possano spesso portare allo stesso risultato. Quindi ha la condizione che utilizza l'intero elenco solo se tutti gli elenchi hanno la stessa lunghezza. Con il salvataggio di soli 3 ~ 5 caratteri e con così tanti avvertimenti, preferisco il codice all'inizio di questo post.

Gelatina , 72 byte

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

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

l'input è di tre matrici, restituisce una stringa

Rubino , 128 byte

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

Provalo online!

C # , 204 203 byte

()=>{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)]}.";};

È la mia prima risposta su questo sito, quindi spero che funzioni bene. Ha anche bisogno di queste tre cose, ma secondo la domanda quelle non contano:

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

Provalo online!

Un byte in meno grazie a Sok.

APL (Dyalog Unicode) , 117 byte ^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]

Provalo online!

?N genera un indice casuale tra i primi N indici.

M?N genera M indici casuali (senza sostituzione) tra i primi N indici.

, è concatenazione

t←T⊃⍨... sceglie una cosa a caso e la chiama tper il riutilizzo nell'ultima riga.

∘,¨ concatena la stringa a sinistra per ogni stringa a destra.

,¨ concatena ogni stringa a sinistra a ciascuna stringa a destra.

↑ cambia l'elenco delle stringhe in una matrice di caratteri in modo che venga stampato correttamente.

Pyth , 88 78 76 byte

JONj_ms.ic"That's
 my 

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

Provalo online!

Il codice presentato sopra richiede la seguente intestazione:

=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")

C'è un piccolo problema con l'uso della funzione 'Header' in TIO con Pyth, in quanto sembra che TIO si unisca ai blocchi di codice su newline, e le nuove righe sono significative in Pyth. Ecco un link allo stesso codice usando il blocco 'Header', con una linea spazzatura nell'output.

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

Modifica: riscrivi in ​​golf 10 byte, versione precedente: 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 byte

Corri con 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?) Byte

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

File batch, 434 424 + 7 byte

Eseguito tramite cmd/q/c.

Codice non conteggiato

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

Codice contato

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.

Esaminerò alcune sfide che dovrai affrontare e spiegherò / giustificherò ciò che ho fatto in modo che altri possano migliorare.

Scegli un elemento casuale da una matrice che
ho fatto generando un numero casuale tra 1e ndov'è nla quantità di elementi in quella matrice. Ho quindi usato questo numero casuale come token per afferrare ogni forloop ( tokens=%r%). Poiché l'ho fatto in questo modo, non potevo più nidificare questi forloop, poiché tokens=!r!non funzionava per me (con espansione ritardata). Ciò avrebbe risparmiato parecchi byte in quanto avrebbe rimosso la necessità di salvare i token come variabili ( set x=%%x).

La generazione di numeri casuali
m è la mia macro di generazione di numeri casuali. In questo modo si risparmia 32 byte rispetto a farlo come set/ar=%random%%%n+1ogni linea. Potresti semi-imbrogliare e decidere che token ye zdevono essere lo stesso 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.

Ciò, pur mantenendo una certa casualità, escluderebbe gli ultimi 6 elementi di c. Ciò consentirebbe di risparmiare un minimo di 20 byte, ma non credo che ciò sia vero per i requisiti dell'operazione.

Miglioramenti teorici che
ho impiegato parecchio tempo cercando di far funzionare questo "pseudo-codice", risparmiando comunque byte:

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%%

Sfortunatamente il setup per questo sta dimostrando di occupare troppi byte per essere redditizio (devono essere implementati in <144 byte) ma non riesco a scuotere la sensazione che l'aggiunta delle ultime 4 righe di codice sia superflua e bizzarra.

inchiostro , 119 byte

~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}

Con le liste definite come

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)

Provalo online!

Sebbene a seconda di ciò che conta come un elenco, ci sono altri approcci. Se un elenco può essere una funzione che restituisce in modo casuale un elemento di elenco, il seguente approccio è di soli 91 byte:

~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}

(con gli "elenchi" definiti come segue)

==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}."

Provalo online!

C'è anche il seguente approccio.

~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}

Provalo online!

Questa soluzione è di 389 byte, ma se i valori letterali shuffle (che in questo scenario non possono essere realmente spostati) vengono conteggiati come definizioni di elenco e possono essere esclusi dal conteggio dei byte, questo scende a 80 byte.

Bash + awk, 209 byte

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}'

Provalo online!

Accetta input come things parts propertiesdove ognuno è un file con un elemento per riga del tipo desiderato.

Questo è un approccio incentrato sui file. Potrebbe provare in seguito un approccio centrato sull'array per vedere se può essere migliorato.

Python 3, 130 byte

Prendendo letteralmente le tue esigenze e prendendo i ritorni a capo di un byte ciascuno:

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