Ce n'est pas mon X, son Y est trop Z

17

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!

code-golf AJFaraday
la source
2
@Shaggy Le premier exemple est le texte réel d'un des livres. Ce n'est pas une réponse valable à ce défi. J'ai dit d'ignorer les pluriels pour simplifier un peu le défi. Cet exemple est essentiellement des informations générales.
AJFaraday
1
En relation
FryAmTheEggman
10
Vous dites "Cela n'a pas besoin de sens.", Cela s'étend-il aux quasi-contractions? (c'est-à-dire "Ce n'est pas mon lapin, ses yeux sont trop brillants. ... C'est mon lapin! Ses yeux sont si brillants." acceptable comme sortie possible?) - Je suppose que oui, je pensais juste vérifier.
Jonathan Allan
13
N'est- ce pas "Il ne doit pas reproduire systématiquement le même texte" et la complexité kolmogorov- incompatible?
Joseph Sible-Reinstate Monica
2
@ChrisH C'est mon erreur taxonomique. Bien que les deux soient classés comme Glires, c'est quelque chose que j'ai appris aujourd'hui.
AJFaraday

Réponses:

1

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

Kevin Cruijssen
la source
10

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

HyperNeutrino
la source
Bon travail! Syntaxe de tuple plus courte: 149 octets
movatica
1
@movatica Ooh, chouette. Merci!
HyperNeutrino
"Ce n'est pas mon renne, ses oreilles sont trop bosselées." - a besoin de quelque chose pour basculer entre est / sont.
John Hunt
1
@JohnHunt les règles disent d'ignorer les pluriels.
HyperNeutrino
Mon erreur. C'est impressionnant
John Hunt
8

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.

Neil
la source
6

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
Incarnation de l'ignorance
la source
Très belle astuce avec "too / so" :)
Shaggy
6

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.

BeowulfNode42
la source
1
Bienvenue chez PPCG! Les parties et les propriétés peuvent être répétées, ce qui devrait vous faire économiser quelques octets.
Shaggy
2
Vous pouvez laisser tomber le Get-de Get-Random. C'est le verbe par défaut testé lors de l'évaluation des commandes.
Matt
2
Bienvenue! Certains golfs faciles vous
ramènent
4

Gelée , 72 octets

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

Essayez-le en ligne!

Erik le Outgolfer
la source
2

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

vityavv
la source
2

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!

Encre de valeur
la source
2

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.

Paweł Mach
la source
1
Bienvenue chez PPCG! J'ai pris la liberté de modifier un lien vers TIO dans votre réponse, afin que les autres puissent facilement essayer votre code par eux-mêmes - je vous aurais donné le lien vers celui-ci dans ce commentaire, mais l'URI était trop long malheureusement! J'espère que vous apprécierez votre séjour: o)
Sok
1
Un petit golf pour vous aussi - le \rn'est pas nécessaire, ce qui vous fera économiser 2 octets.
Sok
1

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.

Adam
la source
1

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

Sok
la source
1

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]."
Silvio Mayolo
la source
1

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()
Développer l'extrait

Onitz
la source
Bienvenue chez Code Golf! Bon travail!
AJFaraday
1
Merci AJ! Appréciez l'accueil :)
Onitz
1

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.

BDM
la source
Vous n'êtes pas autorisé à prendre des entrées via des variables prédéfinies. Vous devrez le prendre comme entrée réelle via l'une des méthodes d'E / S standard
Jo King
1
@JoKing Du défi:The lists of source words are not part of your answer (in TIO they can be added to the header).
AdmBorkBork
Je ne sais pas si cela est autorisé ou non car je l'ai vu faire dans les deux sens dans d'autres réponses, mais pour ceux d'entre vous curieux, cela ajouterait 29 octets à ma réponse sous la forme de set a=%~1, etc.
BDM
1

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.

Sara J
la source
0

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.

LambdaBeta
la source
-2

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")
Accumulation
la source
"Il ne doit pas reproduire systématiquement le même texte." D'après ce que je peux dire, votre code alternera toujours entre l'une des deux options, ce qui me semble être une sortie cohérente. En outre, ce cas de toujours utiliser les mêmes propriétés sur chaque ligne a été explicitement interdit dans les clarifications des commentaires.
Value Ink