Wyzwanie to jest inspirowane serią książek dla małych dzieci autorstwa Fiony Watt i Rachel Wells, które ostatnio bawię się z córką.

W każdej książce mysz (zilustrowana, ale nie część tekstu) narzeka, że ​​seria 5 rzeczy tego samego typu nie jest jego rzeczą. Następnie tworzy kopię zapasową, deklarując, że jakiś element rzeczy nie ma oczekiwanej właściwości.

Po szóstym pytaniu mysz znajduje swoją rzecz i jest zadowolona, ​​ponieważ ma oczekiwaną właściwość.

Oto tekst typowego przykładu:

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.

Teraz większość programistów zdaje sobie sprawę, że jest to bardzo algorytmiczna metoda tworzenia tekstu. Ponieważ jest to tak przejrzysty proces, powinniśmy być w stanie to odtworzyć, pisząc trochę kodu.

Zacznijmy od trzech kolekcji słów:

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

• Najpierw decydujemy, jakie rzeczy będziemy opisywać.
• Następnie 5 razy wygenerujemy wiersz „To nie jest moja [rzecz], jej [część] też jest [właściwość].
• Na koniec generujemy wiersz „To moja [rzecz]! Jego [część] jest tak [własność]!

Wyzwanie

• Wygeneruj tekst opowiadania „To nie jest moja ...”.
• Nie może konsekwentnie odtwarzać tego samego tekstu.
• To jest golf golfowy, więc spróbuj zrobić to w jak najmniejszej liczbie bajtów.
• Użyj dowolnego języka.
• Białe spacje nie mają znaczenia, ale między wierszami musi znajdować się znak nowej linii.
• Listy słów źródłowych nie są częścią twojej odpowiedzi (w TIO można je dodać do nagłówka).
• Możesz zmienić nazwy list słów źródłowych.
• Dane wyjściowe można wyprowadzić do terminala lub wygenerować tekst w obiekcie.
• Podaj link do tłumacza online.
• Ignoruj ​​liczbę mnogą, „jego rogi są” jest w porządku.
• To nie musi mieć sensu. Jeśli lejek twojej księżniczki jest zbyt puszysty, po prostu to powiedz.

Przykładowe dane wyjściowe:

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.

Miłej gry w golfa!

05AB1E , 63 bajty

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

Wypróbuj online.

Wersja 68 bajtów, która nie wyświetla zduplikowanych części ani właściwości:

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

Wypróbuj online.

Oba programy zakładają, że lista rzeczy jest pierwszym wejściem, a lista zawierająca listę części i listę właściwości to drugie wejście.

Wyjaśnienie:

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

Zobacz moją wskazówkę 05AB1E (rozdział Jak korzystać ze słownika? ), Aby zrozumieć, dlaczego “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“jest "that's my ÿ! its ÿ is so ÿ."i “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“jest "that's not my ÿ, its ÿ is too ÿ.".

Python 3 , 149 bajtów

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*

Wypróbuj online!

-9 bajtów dzięki movatica

Węgiel drzewny , 72 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Oczekuje, że tablice rzeczy, części i właściwości znajdą się w zmiennych θ, ηi ζktóre można najłatwiej uporządkować, podając je w danych wejściowych, a nie w nagłówku. Wyjaśnienie:

≔‽θθ

Wybierz przypadkową rzecz.

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

Wydrukuj pięć zdań negatywnych.

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

Wydrukuj zdanie pozytywne.

Japt v2.0a0 -R, 73 bajty

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

Trwa trzy wykazy jak U, Vi W. To i tak są domyślne zmienne wejściowe, więc po prostu umieść trzy listy w sekcji wprowadzania.

Spróbuj

ö                         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 bajtów

Ten program główny nie będzie powtarzał żadnej części ani właściwości w serii i ma rozsądną randomizację.

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

Wypróbuj online!

Pisanie get-randomtyle razy kosztuje tyle znaków! Jednak jeśli nie chcesz, aby części i właściwości były powtarzane, nie widzę sposobu, aby zmniejszyć to w PowerShellu. Chyba że przeniesiesz pierwsze 3 rury potoku na koniec 3 linii przypisania w nagłówku. Mieć coś takiego

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

Ale wydaje się, że to oszustwo i wciąż nie bije odpowiedzi Neila.

Edycja: Dzięki za wskazówki Matt i dzięki AdmBorkBork za ich rozwinięcie, usunięcie 3 zestawów get-tekstu zmniejszyło go do 159 bajtów, a potem trochę więcej golfa z Adm sprowadziło go do 147. Kod, o którym myślałem, który pozwolił na duplikaty i sprzeczne stwierdzenia składały się z 144 znaków po zastosowaniu tych samych wskazówek golfowych.

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

Wypróbuj online!

Jednak nie tylko ma tendencję do powtarzania tego samego wiele razy, ale prawie wymaga, aby twoje dane wejściowe były tej samej liczby elementów. Uważam, że używany generator pseudolosowych liczb jest silnie zależny od zegara, a szybkie powtarzane wywołania często mogą dać ten sam wynik. Następnie ma warunek, że używa całej listy tylko wtedy, gdy wszystkie listy są tej samej długości. Przy zapisaniu tylko 3 ~ 5 znaków i tak wielu zastrzeżeniach, wolę kod na początku tego postu.

Galaretka , 72 bajty

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

Wypróbuj 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)

wejście to trzy tablice, zwraca ciąg znaków

Rubin , 128 bajtów

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

Wypróbuj online!

C # , 204 203 bajtów

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

To moja pierwsza odpowiedź na tej stronie, więc mam nadzieję, że zadziała. Potrzebuje również tych trzech rzeczy, ale według pytania te się nie liczą:

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

Wypróbuj online!

Jeden bajt mniej dzięki Sok.

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

Wypróbuj online!

?N generuje losowy indeks wśród pierwszych N indeksów.

M?N generuje M losowych wskaźników (bez zamiany) wśród pierwszych N wskaźników.

, to konkatenacja

t←T⊃⍨… Wybiera losową rzecz i wzywa ją tdo ponownego użycia w ostatnim wierszu.

∘,¨ łączy ciąg po lewej stronie z każdym ciągiem po prawej stronie.

,¨ łączy każdy ciąg po lewej stronie z każdym ciągiem po prawej stronie.

↑ zmienia listę ciągów znaków na macierz znaków, dzięki czemu drukuje się poprawnie.

Pyth , 88 78 76 bajtów

JONj_ms.ic"That's
 my 

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

Wypróbuj online!

Powyższy kod wymaga następującego nagłówka:

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

Jest mały problem z używaniem funkcji „Nagłówek” w TIO z Pyth, ponieważ wygląda na to, że TIO łączy bloki kodu na nowej linii, a nowe linie są znaczące w Pyth. Oto link do tego samego kodu za pomocą bloku „Nagłówek” z niepotrzebną linią na wyjściu.

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

Edycja: Przepisz do golfa 10 bajtów, poprzednia wersja: 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 bajtów

Uruchom z 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?) Bajtów

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

Plik wsadowy, 434 424 + 7 bajtów

Wykonane przez cmd/q/c.

Kod nie jest liczony

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

Kod został policzony

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.

Przejdę przez niektóre wyzwania, z którymi musisz się zmierzyć, i wyjaśnię / uzasadnię to, co zrobiłem, aby inni mogli je ulepszyć.

Wybierz losowy element z tablicy
Zrobiłem to, generując losową liczbę pomiędzy 1i ngdzie njest ilość elementów w tej tablicy. Następnie użyłem tej losowej liczby jako tokena do przechwycenia w każdej forpętli ( tokens=%r%). Ponieważ zrobiłem to w ten sposób, nie mogłem już zagnieżdżać tych forpętli, ponieważ tokens=!r!nie działało to dla mnie (z opóźnionym rozszerzaniem). Pozwoliłoby to zaoszczędzić sporo bajtów, ponieważ wyeliminowałoby to konieczność zapisywania tokenów jako zmiennych (set x=%%x ).

Generowanie liczb losowych
m to moje makro generowania liczb losowych. Robiąc to w ten sposób oszczędzasz 32 bajty, robiąc to jak set/ar=%random%%%n+1każda linia. Można semi-oszukiwać i podjąć decyzję, że znaki yi zmają być ten sam element:

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.

To, przy zachowaniu pewnej losowości, wykluczałoby ostatnie 6 elementów c . Pozwoliłoby to zaoszczędzić minimum 20 bajtów, ale nie sądzę, że jest to zgodne z wymaganiami operacji.

Teoretyczne udoskonalenia
Spędziłem sporo czasu próbując sprawić, by ten „pseudo-kod” działał, jednocześnie oszczędzając bajty:

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

Niestety konfiguracja tego zajmuje zbyt wiele bajtów, aby była opłacalna (trzeba zaimplementować w <144 bajtach), ale nie mogę się oprzeć wrażeniu, że dodanie 4 ostatnich wierszy kodu jest zbyteczne i zbędne.

atrament , 119 bajtów

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

Z listami zdefiniowanymi jako

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)

Wypróbuj online!

W zależności od tego, co liczy się jako lista, istnieją inne podejścia. Jeśli lista może być funkcją, która losowo zwraca element listy, następujące podejście ma tylko 91 bajtów:

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

(z „listami” zdefiniowanymi w następujący sposób)

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

Wypróbuj online!

Istnieje również następujące podejście.

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

Wypróbuj online!

To rozwiązanie ma 389 bajtów, ale jeśli literały losowe (których w tym scenariuszu tak naprawdę nie można przenieść) liczą się jako definicje list i można je wykluczyć z liczby bajtów, spada to do 80 bajtów.

Bash + awk, 209 bajtów

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

Wypróbuj online!

Akceptuje dane wejściowe jako things parts properties każdy z nich jest plikiem zawierającym jeden element w wierszu żądanego typu.

Jest to podejście skoncentrowane na plikach. Może później wypróbować podejście zorientowane na tablicę, aby sprawdzić, czy można je ulepszyć.

Python 3, 130 bajtów

Dosłownie biorąc twoje wymagania i przyjmując zwrot karetki każdy:

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