Ce défi est inspiré d'une série de livres pour jeunes enfants de Fiona Watt et Rachel Wells, que j'ai récemment appréciés avec ma fille.

Dans chaque livre une souris (illustrée, mais ne faisant pas partie du texte) se plaint qu'une succession de 5 choses du même type ne sont pas sa chose. Il sauvegarde ensuite cela en déclarant que certains composants de la chose n'ont pas la propriété attendue.

Au sixième moment de la demande, la souris trouve sa chose et est contente car elle a la propriété attendue.

Voici le texte d'un exemple typique:

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.

Maintenant, la plupart des programmeurs se rendraient compte qu'il s'agit d'une méthode très algorithmique de production de texte. Parce que c'est un processus tellement clair, nous devrions pouvoir le reproduire en écrivant du code.

Commençons par trois collections de mots:

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

• Tout d'abord, nous décidons quel genre de chose nous allons décrire.
• Ensuite, 5 fois, nous générerons la ligne "Ce n'est pas mon [truc], sa [partie] est trop [propriété].
• Enfin, nous générons la ligne "C'est mon [truc]! Sa [partie] est tellement [propriété]!

Le défi

• Générez le texte d'une histoire "Ce n'est pas mon ...".
• Il ne doit pas reproduire systématiquement le même texte.
• C'est du golf de code, essayez donc de le faire dans le plus petit nombre d'octets.
• Utilisez la langue de votre choix.
• L'espace blanc n'a pas d'importance, mais il doit y avoir un caractère de nouvelle ligne entre les lignes.
• Les listes de mots sources ne font pas partie de votre réponse (dans TIO, elles peuvent être ajoutées à l'en-tête).
• Vous pouvez renommer les listes de mots sources.
• La sortie peut être sortie vers un terminal ou du texte généré dans un objet.
• Veuillez inclure un lien vers un interprète en ligne.
• Ignorez les pluriels, "ses cornes est" est très bien.
• Cela n'a pas besoin de sens. Si l'entonnoir de votre princesse est trop moelleux, dites-le.

Exemple de sortie:

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.

Bon golf!

05AB1E , 63 octets

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

Essayez-le en ligne.

Version de 68 octets qui ne produit ni pièces ni propriétés dupliquées:

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

Essayez-le en ligne.

Les deux programmes supposent que la liste des choses est la première entrée, et une liste contenant la liste des parties et la liste des propriétés est la deuxième entrée.

Explication:

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

Voir cette astuce 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“est "that's my ÿ! its ÿ is so ÿ."et “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“est "that's not my ÿ, its ÿ is too ÿ.".

Python 3 , 149 octets

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*

Essayez-le en ligne!

-9 octets grâce à movatica

Fusain , 72 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Attend que les tableaux de choses, de pièces et de propriétés soient dans les variablesθ , ηet ζqui est le plus facile à arranger en leur fournissant dans l'entrée plutôt que l' en- tête. Explication:

≔‽θθ

Choisissez une chose aléatoire.

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

Imprimez cinq phrases négatives.

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

Imprimez la phrase positive.

Japt v2.0a0 -R, 73 octets

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

Prend les trois listes comme U,V et W. Ce sont les variables d'entrée par défaut de toute façon, alors mettez simplement les trois listes dans la section d'entrée.

Essayez-le

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

Ce programme principal ne répétera aucune partie ou propriété dans une exécution et a une randomisation raisonnable.

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

Essayez-le en ligne!

Écrire get-randomtant de fois coûte tellement de caractères! Cependant, à moins que vous ne vouliez laisser les pièces et les propriétés se répéter, je ne vois pas de moyen de réduire davantage cela en PowerShell. À moins que vous ne déplaciez les 3 premiers tubes de ligne à la fin des 3 lignes d'affectation dans l'en-tête. Pour avoir quelque chose comme

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

Mais cela semble tricher, et ne bat toujours pas la réponse de Neil.

Edit: Merci pour les conseils Matt, et merci AdmBorkBork pour les avoir étoffés, la suppression des 3 ensembles de get-texte l'a réduit à 159 octets, puis un peu plus de golf d'Adm l'a réduit à 147. Le code auquel je pensais permettait les doublons et déclarations contradictoires était de 144 caractères après avoir appliqué les mêmes conseils de 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)]

Essayez-le en ligne!

Cependant, non seulement il a tendance à répéter la même chose plusieurs fois, mais il nécessite à peu près que vos entrées aient le même nombre d'éléments. Je crois que le générateur de nombres pseudo-aléatoires utilisé dépend fortement de l'horloge, et des appels répétés rapides peuvent souvent aboutir au même résultat. Ensuite, il a la condition qu'il n'utilise la liste entière que si toutes les listes sont de la même longueur.

Gelée , 72 octets

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

Essayez-le en ligne!

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'entrée est trois tableaux, renvoie une chaîne

Rubis , 128 octets

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

Essayez-le en ligne!

C # , 204 203 octets

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

C'est ma première réponse sur ce site, j'espère donc que cela fonctionne bien. Il a également besoin de ces trois choses, mais selon la question, elles ne comptent pas:

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

Essayez-le en ligne!

Un octet de moins grâce à Sok.

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

Essayez-le en ligne!

?N génère un indice aléatoire parmi les N premiers indices.

M?N génère M indices aléatoires (sans remplacement) parmi les N premiers indices.

, est la concaténation

t←T⊃⍨… Choisit une chose au hasard et l'appelle tpour réutilisation dans la dernière ligne.

∘,¨ concatène la chaîne de gauche à chaque chaîne de droite.

,¨ concatène chaque chaîne de gauche à chaque chaîne de droite.

↑ change la liste des chaînes en une matrice de caractères pour qu'elle s'imprime correctement.

Pyth , 88 78 76 octets

JONj_ms.ic"That's
 my 

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

Essayez-le en ligne!

Le code présenté ci-dessus nécessite l'en-tête suivant:

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

Il y a un petit problème avec l'utilisation de la fonctionnalité `` En-tête '' dans TIO avec Pyth, car il semble que TIO rejoint les blocs de code sur les nouvelles lignes, et les nouvelles lignes sont importantes en Pyth. Voici un lien vers le même code en utilisant le bloc «En-tête», avec une ligne indésirable en sortie.

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: Réécriture sur golf 10 octets, version précédente: 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 octets

Courez avec 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?) Octets

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

Fichier de commandes, 434 424 + 7 octets

Exécuté via cmd/q/c .

Code non compté

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

Code compté

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.

Je vais passer en revue certains défis que vous devez relever et expliquer / justifier ce que j'ai fait pour que d'autres puissent s'améliorer.

Choisissez un élément aléatoire dans un tableau que
j'ai fait en générant un nombre aléatoire entre 1etn où nest la quantité d'éléments dans ce tableau. J'ai ensuite utilisé ce nombre aléatoire comme jeton à saisir dans chaque forboucle ( tokens=%r%). Parce que je l'ai fait de cette façon, je ne pouvais plus imbriquer ces forboucles, car cela tokens=!r!ne fonctionnait pas pour moi (avec une expansion retardée). Cela aurait sauvé pas mal d'octets car cela aurait supprimé la nécessité de sauvegarder les jetons en tant que variables ( set x=%%x).

Génération de nombres aléatoires
m est ma macro de génération de nombres aléatoires. Le faire de cette façon économise 32 octets par rapport à le faire comme set/ar=%random%%%n+1chaque ligne. Vous pouvez semi-triche et de décider que les jetons yet zdoivent être les même élément:

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.

Cela, tout en conservant un certain caractère aléatoire, exclurait les 6 derniers éléments de c . Cela permettrait d'économiser au moins 20 octets, mais je ne pense pas que cela soit conforme aux exigences de l'op.

Améliorations théoriques
J'ai passé un bon moment à essayer de faire fonctionner ce "pseudo-code", tout en économisant des octets:

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

Malheureusement, la configuration pour cela s'avère prendre beaucoup trop d'octets pour être rentable (doit être implémentée en <144 octets) mais je ne peux pas secouer le sentiment que l'ajout des 4 dernières lignes de code est superflu et janky.

encre , 119 octets

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

Avec les listes définies comme

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)

Essayez-le en ligne!

Bien qu'en fonction de ce qui compte comme une liste, il existe d'autres approches. Si une liste peut être une fonction qui renvoie aléatoirement un élément de liste, l'approche suivante n'est que de 91 octets:

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

(avec les "listes" définies comme suit)

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

Essayez-le en ligne!

Il y a aussi l'approche suivante.

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

Essayez-le en ligne!

Cette solution est de 389 octets, mais si les littéraux shuffle (qui dans ce scénario ne peuvent pas vraiment être déplacés) comptent comme définitions de liste et peuvent être exclus du nombre d'octets, cela tombe à 80 octets.

Bash + awk, 209 octets

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

Essayez-le en ligne!

Accepte les entrées comme things parts propertiesoù chacune est un fichier avec un élément par ligne du type souhaité.

Il s'agit d'une approche centrée sur les fichiers. Peut essayer une approche centrée sur les tableaux plus tard pour voir si elle peut être améliorée.

Python 3, 130 octets

Prendre vos besoins au pied de la lettre et prendre les retours chariot à un octet chacun:

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