Diese Herausforderung ist inspiriert von einer Reihe von Kinderbüchern von Fiona Watt und Rachel Wells, die ich kürzlich mit meiner Tochter genossen habe.

In jedem Buch beklagt sich eine Maus (illustriert, aber nicht Teil des Textes), dass eine Abfolge von 5 Dingen desselben Typs nicht ihre Sache ist. Es sichert dies dann, indem es erklärt, dass eine Komponente der Sache nicht die Eigenschaft hat, die sie erwartet.

Beim sechsten Mal findet die Maus ihr Ding und freut sich, weil sie die erwartete Eigenschaft hat.

Hier ist der Text eines typischen Beispiels:

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.

Jetzt würden die meisten Programmierer erkennen, dass dies eine sehr algorithmische Methode zur Erzeugung von Text ist. Da es sich um einen so klaren Prozess handelt, sollten wir dies reproduzieren können, indem wir Code schreiben.

Beginnen wir mit drei Wortsammlungen:

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

• Zuerst entscheiden wir, welche Art von Dingen wir beschreiben werden.
• Dann erzeugen wir 5 Mal die Zeile "Das ist nicht mein Ding, sein Teil ist auch Eigentum.
• Schließlich erzeugen wir die Zeile "Das ist mein [Ding]! Sein [Teil] ist so [Eigentum]!

Die Herausforderung

• Generieren Sie den Text einer "Das ist nicht meine ..." Geschichte.
• Es darf nicht immer derselbe Text wiedergegeben werden.
• Es ist Codegolf, also versuchen Sie es mit der kleinsten Anzahl von Bytes.
• Verwenden Sie eine beliebige Sprache.
• Leerzeichen spielen keine Rolle, aber zwischen den Zeilen muss ein Zeilenumbruch stehen.
• Die Listen der Quellwörter sind nicht Teil Ihrer Antwort (in TIO können sie der Kopfzeile hinzugefügt werden).
• Sie können die Listen der Quellwörter umbenennen.
• Die Ausgabe kann an ein Terminal erfolgen oder in ein Objekt generierter Text.
• Bitte fügen Sie einen Link zu einem Online-Dolmetscher bei.
• Plurale ignorieren, "seine Hörner sind" ist in Ordnung.
• Es muss keinen Sinn ergeben. Wenn Trichter Ihrer Prinzessin zu flauschig ist, sagen Sie einfach so.

Beispielausgabe:

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.

Viel Spaß beim Golfen!

05AB1E , 63 Bytes

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

Probieren Sie es online aus.

68- Byte- Version, die keine duplizierten Teile oder Eigenschaften ausgibt:

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

Probieren Sie es online aus.

Beide Programme nimmt die Liste der Dinge, ist der erste Eingang und eine Liste, die Liste der Teile und die Liste der Eigenschaften enthält, ist der zweite Eingang.

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie verwende ich das Wörterbuch? ) An, um zu verstehen, warum es “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ist "that's my ÿ! its ÿ is so ÿ."und “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“ist "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*

Probieren Sie es online!

-9 bytes dank movatica

Kohle , 72 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erwartet , dass die Anordnungen von Dingen, Teilen und Eigenschaften in den Variablen zu seinθ , ηund ζ, was am einfachsten , indem sie in dem Eingang anstelle dem Kopf angeordnet ist. Erläuterung:

≔‽θθ

Wähle eine zufällige Sache.

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

Drucken Sie fünf negative Sätze.

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

Drucken Sie den positiven Satz aus.

Japt v2.0a0 -R, 73 Bytes

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

Nimmt die drei Listen als U,V und W. Das sind die Eingabestandardvariablen sowieso, so dass nur die drei Listen in dem Eingabebereich setzen.

Versuch es

ö                         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

Power Shell , 147 Byte

Das Hauptprogramm wird kein Teil oder Eigenschaft in einem Lauf wiederholen, und hat angemessene Randomisierung.

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

Probieren Sie es online!

Schreiben get-randomSo oft zu kostet so viele Zeichen! Wenn Sie jedoch nicht bereit sind, Teile und Eigenschaften wiederholen zu lassen, kann ich keinen Weg finden, dies in PowerShell weiter zu reduzieren. Es sei denn, Sie verschieben die ersten 3 Zeilenpipes an das Ende der 3 Zuweisungszeilen im Header. So etwas zu haben

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

Aber das scheint zu schummeln und schlägt Neils Antwort immer noch nicht.

Bearbeiten: Vielen Dank für die Tipps Matt, und danke AdmBorkBork für die Ausarbeitung, Entfernen der 3 Sätze von get-Text reduziert es auf 159 Bytes, dann etwas mehr Golf von Adm bekam es auf 147. Der Code, an den ich dachte, erlaubt Duplikate und widersprüchliche Angaben waren 144 Zeichen nach Anwenden der gleichen Golftipps.

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

Probieren Sie es online!

Es besteht jedoch nicht nur die Tendenz, dasselbe mehrmals auszusprechen, sondern es ist auch so ziemlich erforderlich, dass Ihre Eingaben dieselbe Anzahl von Elementen aufweisen. Ich glaube, der verwendete Pseudozufallszahlengenerator ist stark von der Uhr abhängig, und schnelle wiederholte Aufrufe können oft zu demselben Ergebnis führen. Dann hat es die Bedingung, dass es nur die ganze Liste verwendet, wenn alle Listen die gleiche Länge haben. Mit nur 3 ~ 5 Zeichen und so vielen Vorbehalten bevorzuge ich den Code am Anfang dieses Beitrags.

Jelly , 72 Bytes

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

Probieren Sie es 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)

Die Eingabe besteht aus drei Arrays und gibt einen String zurück

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

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

Es ist meine erste Antwort auf dieser Seite, also hoffe ich, dass es gut funktioniert. Es braucht auch diese drei Dinge, aber laut Frage zählen diese nicht:

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

Probieren Sie es online!

Ein Byte weniger dank 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]

Probieren Sie es online!

?N erzeugt einen Zufallsindex unter den ersten N Indizes.

M?N erzeugt M zufällige Indizes (ohne Ersatz) unter den ersten N Indizes.

, ist Verkettung

t←T⊃⍨… Wählt eine zufällige Sache und nennt sie t in der letzten Zeile zur Wiederverwendung auf.

∘,¨ Verkettet die Zeichenfolge links mit jeder Zeichenfolge rechts.

,¨ verkettet jede Zeichenfolge auf der linken Seite mit jeder Zeichenfolge auf der rechten Seite.

↑ Ändert die Liste der Zeichenfolgen in eine Zeichenmatrix, sodass sie richtig gedruckt wird.

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

Probieren Sie es online!

Der oben dargestellte Code erfordert den folgenden Header:

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

Es gibt ein kleines Problem bei der Verwendung der 'Header'-Funktion in TIO mit Pyth, da es so aussieht, als ob TIO die Codeblöcke in Zeilenumbrüchen zusammenfügt und Zeilenumbrüche in Pyth von Bedeutung sind. Hier ist ein Link zu demselben Code, der den 'Header'-Block mit einer Junk-Zeile in der Ausgabe verwendet.

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: Umschreiben auf Golf 10 Bytes, Vorgängerversion: 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

Laufen Sie mit 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()

Batch-Datei, 434 424 + 7 Bytes

Ausgeführt über cmd/q/c.

Code nicht gezählt

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 gezählt

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.

Ich gehe einige Herausforderungen durch, denen du dich stellen musst, und erkläre / begründe, was ich getan habe, damit andere sich verbessern können.

Wählen Sie ein zufälliges Element aus einem Array aus.
Dazu haben Sie eine Zufallszahl zwischen 1und nwo nbefindet sich die Anzahl der Elemente in diesem Array? Ich habe dann diese Zufallszahl als Token verwendet, um in jeder forSchleife zu greifen ( tokens=%r%). Weil ich es so gemacht habe, konnte ich diese forSchleifen nicht mehr verschachtelntokens=!r! es bei mir nicht funktionierte (mit verzögerter Erweiterung). Dies hätte einige Bytes gespart, da die Token nicht mehr als Variablen gespeichert werden müssten (set x=%%x ) .

Zufallszahlengenerierung
m ist mein Zufallszahlengenerierungsmakro. Wenn Sie dies so tun, sparen Sie 32 Bytes mehr als bei set/ar=%random%%%n+1jeder anderen Zeile. Sie könnten halb betrügen und dass Token entscheiden yund zsind das gleiche Element sein:

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.

Dies würde unter Beibehaltung einer gewissen Zufälligkeit die letzten 6 Elemente von ausschließen c. Dies würde ein Minimum von 20 Bytes einsparen, aber ich denke nicht, dass dies den Anforderungen der Operation entspricht.

Theoretische Verbesserungen
Ich habe eine ganze Weile versucht, diesen "Pseudo-Code" zum Laufen zu bringen und dabei immer noch Bytes zu sparen:

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

Leider nimmt das Setup dafür viel zu viele Bytes in Anspruch, um rentabel zu sein (muss in <144 Bytes implementiert werden), aber ich kann das Gefühl nicht loswerden, dass das Hinzufügen der letzten 4 Codezeilen überflüssig und ruckelig ist.

Tinte , 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}

Mit den Listen definiert als

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)

Probieren Sie es online!

Abhängig davon, was als Liste zählt, gibt es andere Ansätze. Wenn eine Liste eine Funktion sein kann, die ein Listenelement zufällig zurückgibt, beträgt der folgende Ansatz nur 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}

(mit den "Listen" wie folgt definiert)

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

Probieren Sie es online!

Es gibt auch den folgenden Ansatz.

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

Probieren Sie es online!

Diese Lösung hat 389 Bytes, aber wenn die Shuffle-Literale (die in diesem Szenario nicht wirklich verschoben werden können) als Listendefinitionen gelten und von der Byteanzahl ausgeschlossen werden können, sinkt diese auf 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}'

Probieren Sie es online!

Akzeptiert Eingaben als things parts properties eine Datei mit einem Element pro Zeile des gewünschten Typs.

Dies ist ein dateizentrierter Ansatz. Möglicherweise versuchen Sie später einen Array-zentrierten Ansatz, um festzustellen, ob er verbessert werden kann.

Python 3, 130 Bytes

Nehmen Sie Ihre Anforderungen wörtlich und setzen Sie die Zeilenumbrüche auf jeweils ein Byte:

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