Esa no es mi X, es Y también es Z

17

Este desafío está inspirado en una serie de libros para niños pequeños de Fiona Watt y Rachel Wells, que recientemente he estado disfrutando con mi hija.

En cada libro, un mouse (ilustrado, pero no parte del texto) se queja de que una sucesión de 5 cosas del mismo tipo no son lo suyo. Luego respalda esto al declarar que algún componente de la cosa no tiene la propiedad que espera.

En la sexta vez que pregunta, el ratón encuentra lo suyo y está contento porque tiene la propiedad esperada.

Aquí está el texto de un ejemplo 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.

Ahora, la mayoría de la gente de programación se daría cuenta de que este es un método muy algorítmico para producir texto. Debido a que es un proceso tan claro, deberíamos poder reproducir esto escribiendo algún código.

Comencemos con tres colecciones de palabras:

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"]
  • Primero, decidimos qué tipo de cosas describiremos.
  • Luego, 5 veces, generaremos la línea "Esa no es mi [cosa], su [parte] es también [propiedad].
  • Finalmente, generamos la línea "¡Esa es mi [cosa]! Su [parte] es tan [propiedad]!

El reto

  • Genere el texto de una historia de "Ese no es mi ...".
  • No debe reproducir constantemente el mismo texto.
  • Es un código de golf, así que intente hacerlo en el menor número de bytes.
  • Use cualquier idioma que desee.
  • El espacio en blanco no importa, pero debe haber un carácter de nueva línea entre líneas.
  • Las listas de palabras de origen no son parte de su respuesta (en TIO se pueden agregar al encabezado).
  • Puede cambiar el nombre de las listas de palabras de origen.
  • La salida puede enviarse a un terminal o texto generado en un objeto.
  • Incluya un enlace a un intérprete en línea.
  • Ignora los plurales, "sus cuernos es" está bien.
  • No tiene que tener sentido. Si el embudo de tu princesa es demasiado esponjoso, solo dilo.

Salida de muestra:

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 golf!

code-golf AJFaraday
fuente
2
@Shaggy El primer ejemplo es el texto real de uno de los libros. No es una respuesta válida para este desafío. He dicho que ignore los plurales para simplificar un poco el desafío. Ese ejemplo es básicamente información de fondo.
AJFaraday
1
Relacionado
FryAmTheEggman
10
Usted dice "No tiene que tener sentido", ¿eso se extiende a casi contracciones? (es decir, "Ese no es mi conejito, sus ojos son demasiado brillantes ... ¡Ese es mi conejito! Sus ojos son tan brillantes" ¿aceptable como posible salida?) - Supongo que sí, solo pensé en comprobarlo.
Jonathan Allan
13
¿No es "No debe reproducir constantemente el mismo texto" y el tipo de complejidad kolmogorov es incompatible?
Joseph Sible-Reinstate Monica
2
@ChrisH Ese es mi error taxonómico. Aunque ambos están clasificados como Glires, eso es algo que aprendí hoy.
AJFaraday

Respuestas:

1

05AB1E , 63 bytes

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

Pruébalo en línea.

Versión de 68 bytes que no genera partes ni propiedades duplicadas:

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

Pruébalo en línea.

Ambos programas asumen que la lista de cosas es la primera entrada, y una lista que contiene la lista de partes y la lista de propiedades es la segunda entrada.

Explicación:

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

Vea esta sugerencia mía 05AB1E (sección ¿Cómo usar el diccionario? ) Para comprender por qué “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“es "that's my ÿ! its ÿ is so ÿ."y “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“es "that's not my ÿ, its ÿ is too ÿ.".

Kevin Cruijssen
fuente
10

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*

Pruébalo en línea!

-9 bytes gracias a movatica

Hiperneutrino
fuente
¡Buen trabajo! Sintaxis de tupla más corta: 149 bytes
movatica
1
@movatica Ooh, bien. ¡Gracias!
HyperNeutrino
"Ese no es mi reno, sus orejas están demasiado llenas de baches". - necesita algo para cambiar entre is / are.
John Hunt
1
@JohnHunt las reglas dicen ignorar los plurales.
HyperNeutrino
Mi error. Esto es muy impresionante
John Hunt
8

Carbón de leña , 72 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Espera que las matrices de las cosas, las partes y propiedades para estar en las variables θ, ηy ζ, que está más fácilmente dispuesto proporcionándoles en la entrada en lugar de la cabecera. Explicación:

≔‽θθ

Elige una cosa al azar.

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

Imprime cinco oraciones negativas.

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

Imprime la oración positiva.

Neil
fuente
6

Japt v2.0a0 -R, 73 bytes

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

Toma las tres listas como U, VyW . Esas son las variables de entrada predeterminadas de todos modos, así que solo ponga las tres listas en la sección de entrada.

Intentalo

ö                         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
Encarnación de la ignorancia
fuente
Muy buen truco con "too / so" :)
Shaggy
6

Potencia Shell , 147 bytes

Este programa principal no repetirá ninguna parte o propiedad en una ejecución y tiene una aleatorización razonable. 

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

Pruébalo en línea!

¡Escribir get-randomtantas veces cuesta tantos caracteres! Sin embargo, a menos que esté dispuesto a permitir que las partes y propiedades se repitan, no puedo ver una forma de reducir esto en PowerShell. A menos que mueva las primeras 3 líneas al final de las 3 líneas de asignación en el encabezado. Tener 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]

Pero parece que está haciendo trampa, y todavía no supera la respuesta de Neil.

Editar: Gracias por los consejos Matt, y gracias AdmBorkBork por desarrollarlos, eliminar los 3 conjuntos de get-texto lo redujo a 159 bytes, luego un poco más de golf de Adm lo redujo a 147. El código en el que estaba pensando permitía duplicados y declaraciones contradictorias fueron 144 caracteres después de aplicar los mismos consejos 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)]

Pruébalo en línea!

Sin embargo, no solo tiene la tendencia de decir lo mismo varias veces, sino que requiere que sus entradas tengan la misma cantidad de elementos. Creo que el generador de números pseudoaleatorios que se usa depende en gran medida del reloj, y las llamadas rápidas repetidas a menudo pueden dar como resultado el mismo resultado. Luego tiene la condición de que solo use la lista completa si todas las listas tienen la misma longitud. Con solo guardar 3 ~ 5 caracteres y tener tantas advertencias, prefiero el código al comienzo de esta publicación.

BeowulfNode42
fuente
1
Bienvenido a PPCG! Las partes y propiedades pueden repetirse para que le ahorre algunos bytes.
Shaggy
2
Puedes soltar el Get-de Get-Random. Es el verbo predeterminado probado al evaluar comandos.
Matt
2
¡Bienvenido! Algunos campos de golf fáciles lo
llevan
4

Jalea , 72 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
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)

la entrada es tres matrices, devuelve cadena

vityavv
fuente
2

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

Pruébalo en línea!

Tinta de valor
fuente
2

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

Es mi primera respuesta en este sitio, así que espero que funcione bien. También necesita esas tres cosas, pero según la pregunta, esas no cuentan:

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

Pruébalo en línea!

Un byte menos gracias a Sok.

Paweł Mach
fuente
1
Bienvenido a PPCG! Me tomé la libertad de editar un enlace a TIO en su respuesta, para que otros puedan probar fácilmente su código por sí mismos. ¡Le hubiera dado el enlace en este comentario, pero desafortunadamente el URI fue demasiado largo! Espero que disfrutes tu estancia: o)
Sok
1
Un pequeño campo de golf para ti también: \rno es obligatorio, lo que te ahorrará 2 bytes.
Sok
1

APL (Dyalog Unicode) , SBCS de 117 bytes

↑('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]

Pruébalo en línea!

?N genera un índice aleatorio entre los primeros N índices.

M?N genera M índices aleatorios (sin reemplazo) entre los primeros N índices.

, es concatenación

t←T⊃⍨... elige una cosa al azar y la llama t para su reutilización en la última línea.

∘,¨ concatena la cadena de la izquierda a cada cadena de la derecha.

,¨ concatena cada cadena a la izquierda con cada cadena a la derecha.

↑ cambia la lista de cadenas en una matriz de caracteres para que se imprima correctamente.

Adán
fuente
1

Pyth , 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

Pruébalo en línea!

El código presentado anteriormente requiere el siguiente encabezado:

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

Hay un pequeño problema con el uso de la función 'Encabezado' en TIO con Pyth, ya que parece que TIO une los bloques de código en las nuevas líneas, y las nuevas líneas son importantes en Pyth. Aquí hay un enlace al mismo código usando el bloque 'Encabezado', con una línea basura en la salida.

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

Editar: reescribir a golf 10 bytes, versión anterior: J+" my "ONV5%"That's not%s, its %s is too %s."[JOGOH;%"That's%s! Its %s is so %s."[JOGOH

Sok
fuente
1

Perl 5.10, 127 bytes

Corre 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]."
Silvio Mayolo
fuente
1

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

Onitz
fuente
¡Bienvenido a Code Golf! ¡Buen trabajo!
AJFaraday
1
Gracias AJ!
Agradezco
1

Archivo por lotes, 434 424 + 7 bytes

Ejecutado vía cmd/q/c.

Código no 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.

Revisaré algunos desafíos que debes enfrentar y explicaré / justificaré lo que hice para que otros puedan mejorar.

Elija un elemento aleatorio de una matriz.
Hice esto generando un número aleatorio entre 1y ndónde nestá la cantidad de elementos en esa matriz. Luego usé este número aleatorio como el token para agarrar en cada forbucle ( tokens=%r%). Debido a que lo hice de esta manera, ya no podía anidar estos forbucles, ya que tokens=!r!no funcionaba para mí (con una expansión retrasada). Esto habría ahorrado bastantes bytes, ya que habría eliminado la necesidad de guardar los tokens como variables (set x=%%x ).

Generación de números aleatorios
m es mi macro de generación de números aleatorios. Hacerlo de esta manera ahorra 32 bytes al hacerlo como set/ar=%random%%%n+1cada línea. Se podría semi-trampa y decide que los tokens yy zestá siendo el mismo 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.

Esto, si bien aún conserva algo de aleatoriedad, excluiría los 6 elementos finales de c . Esto ahorraría un mínimo de 20 bytes, pero no creo que esto sea fiel a los requisitos del operador.

Mejoras teóricas
Pasé bastante tiempo tratando de hacer que este "pseudocódigo" funcione, sin dejar de guardar 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%%

Desafortunadamente, la configuración para esto está probando tomar demasiados bytes para ser rentable (tiene que implementarse en <144 bytes), pero no puedo evitar la sensación de que agregar las últimas 4 líneas de código es superfluo y extraño.

BDM
fuente
No está permitido tomar entradas a través de variables predefinidas. Tendrá que tomarlo como entrada real a través de cualquiera de los métodos estándar de E / S
Jo King
1
@JoKing Del desafío:The lists of source words are not part of your answer (in TIO they can be added to the header).
AdmBorkBork
No estoy seguro de si está permitido o no, como lo he visto en ambos sentidos en otras respuestas, pero para aquellos que tengan curiosidad, agregaría 29 bytes a mi respuesta en forma de set a=%~1, etc.
BDM
1

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}

Con las 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)

Pruébalo en línea!

Aunque dependiendo de lo que cuenta como una lista, hay otros enfoques. Si una lista puede ser una función que devuelve aleatoriamente un elemento de la lista, el siguiente enfoque es de solo 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}

(con las "listas" definidas de la siguiente manera)

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

Pruébalo en línea!

También existe el siguiente enfoque.

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

Pruébalo en línea!

Esta solución es de 389 bytes, pero si los literales aleatorios (que en este escenario realmente no se pueden mover) cuentan como definiciones de lista y pueden excluirse del recuento de bytes, esto se reduce a 80 bytes.

Sara J
fuente
0

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

Pruébalo en línea!

Acepta entradas como things parts properties donde cada una es un archivo con un elemento por línea del tipo deseado.

Este es un enfoque centrado en el archivo. Puede intentar un enfoque centrado en la matriz más adelante para ver si se puede mejorar.

LambdaBeta
fuente
-2

Python 3, 130 bytes

Tomando sus requisitos literalmente, y tomando los retornos de carro para que sean un byte cada uno:

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")
Acumulacion
fuente
"No debe reproducir constantemente el mismo texto". Por lo que puedo decir, su código siempre alternará entre una de dos opciones, lo que me parece una salida consistente. Además, este caso de usar siempre las mismas propiedades en cada línea ha sido explícitamente rechazado en las aclaraciones de comentarios.
Value Ink