Oto (dość przerażająca) piosenka Five little ducks (nie jest długa):

Five little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only four little ducks came back.

Four little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only three little ducks came back.

Three little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only two little ducks came back.

Two little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only one little duck came back.

One little duck went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but none of the little ducks came back.

Mother duck herself went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
and all of the little ducks came back.

Twoim zadaniem nie jest wydanie tej piosenki. Powinieneś wziąć werset i wypisać następny werset (następny werset ostatniego wersetu to pierwszy werset).

Zasady

• Poproszę o brak standardowych luk.
• Wejścia / wyjścia będą pobierane za pomocą naszych standardowych metod wejścia / wyjścia.
• Dokładny wiersz musi być wyprowadzany, i nie powinno być żadnych różnic w porównaniu do tekstów piosenek. Dane wejściowe nie będą się różnić w porównaniu z tekstami piosenek.

Przykłady

Mother duck herself went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
and all of the little ducks came back.

Spodziewany:

Five little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only four little ducks came back.

Three little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only two little ducks came back.

Spodziewany:

Two little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only one little duck came back.

Stax , 115 111 bajtów

τ*^&k─Zè0µ9┬$█◘çl╟☼:Drσ59ò╠▄┴╢Q♂╔¡ô╜Oa╣▀yèA÷╨%^♀█Ö+╡◄ì=∙%╧o▌Θ<▲Çα¿╗√;1°┼╤V◘ú┐♥▒ÇM☼b╩░o]YaL4░ƒ%(Æ♫Q0æÆä⌂¡╘○Eâó╪¡

Uruchom i debuguj

Wszystkie wiersze jako przypadki testowe

JavaScript (ES9), 227 bajtów

Jest to podobne do poniższej wersji Węzła, ale wykorzystuje formułę opartą na parseInt()zamiast Buffer()do identyfikacji wersetu wejściowego.

To jest ES2018 (alias ES9), ponieważ używamy wyrażenia regularnego z /sflagą ( dotAll ).

s=>'Mother duck herself1and all23,,Three4two3,Five4four3,Four4three3,One01but none23,Two4one0'.split`,`[parseInt(s,30)&7].replace(/\d/g,n=>[x=' little duck',y=/ w.*\n/s.exec(s),' of the',x+='s',x+y+'but only '][n])+s.slice(-11)

Wypróbuj online!

W jaki sposób?

W tej wersji analizujemy cały wiersz wejściowy jako bazę 30 ( 0do t) i wykonujemy bitowe AND z 7. Parsowanie zatrzymuje się na pierwszym nieprawidłowym znaku, co prowadzi do:

 verse | valid part | base 30 -> decimal | AND 7
-------+------------+--------------------+-------
   0   |  'fi'      |            468     |   4
   1   |  'fo'      |            474     |   2
   2   |  'three'   |       23973734     |   6
   3   |  't'       |             29     |   5
   4   |  'one'     |          22304     |   0
   5   |  'mother'  |      554838747     |   3

JavaScript (Node.js) ,  233 231  227 bajtów

Zaoszczędzono 2 bajty dzięki @Shaggy

s=>'Three4two3,Four4three3,Mother duck herself1and all23,One01but none23,,,Two4one0,,Five4four3'.split`,`[Buffer(s)[2]%9].replace(/\d/g,n=>[x=' little duck',y=/ w.*\n/s.exec(s),' of the',x+='s',x+y+'but only '][n])+s.slice(-11)

Wypróbuj online!

W jaki sposób?

Trzeci znak każdego wiersza wejściowego może być użyty jako unikalny identyfikator. Biorąc jego kod ASCII modulo 9, otrzymujemy:

 verse | 3rd char. | ASCII code | MOD 9
-------+-----------+------------+-------
   0   |    'v'    |     118    |   1
   1   |    'u'    |     117    |   0
   2   |    'r'    |     114    |   6
   3   |    'o'    |     111    |   3
   4   |    'e'    |     101    |   2
   5   |    't'    |     116    |   8

Wersety wyjściowe są kodowane za pomocą następujących szablonów:

 verse | template
-------+---------------------------------
   0   | 'Five4four3'
   1   | 'Four4three3'
   2   | 'Three4two3'
   3   | 'Two4one0'
   4   | 'One01but none23'
   5   | 'Mother duck herself1and all23'

Gdzie każdą cyfrę zastępuje się ciągiem zgodnie z następującą tabelą:

 digit | replaced with
-------+---------------------------------------------------
   0   | ' little duck'
   1   | / w.*\n/s.exec(s)
   2   | ' of the'
   3   | ' little ducks'
   4   | ' little ducks' + / w.*\n/s.exec(s) + 'but only '

Gdy wyrażenie regularne / w.*\n/swyodrębnia tę wspólną część z danych wejściowych:

  went out one day,[LF]
 over the hills and up away.[LF]
 Mother Duck said, "Quack Quack Quack Quack",[LF]

W końcu dodajemy ostatnie 11 znaków wejścia, czyli " came back.".

Python 3 , 267 263 254 bajtów

4 bajty zapisane dzięki @ovs

def f(s):
 for a in zip(T[2:]+T,T):s=s.replace(*a)
 return s
T="8:9:and allHO1BnoneHT2No1T3Nt2F4Nt3FiveINf4MotherD herself"
for r in "H of theI,4ourI,3hreeI,2woI,1neL:,ILs:,L littleD,D duck,NBonly ,Bbut ".split(','):T=T.replace(r[0],r[1:])
T=T.split(':')

Wypróbuj online!

Działa poprzez zastąpienie odpowiednich części odpowiednimi częściami następnego wersetu.

Po wstępnej inicjalizacji Tjest ['8', '9', 'and all of the little ducks', 'One little duck', 'but none of the little ducks', 'Two little ducks', 'but only one little duck', 'Three little ducks', 'but only two little ducks', 'Four little ducks', 'but only three little ducks', 'Five little ducks', 'but only four little ducks', 'Mother duck herself'].

Alternatywny Python 2 , 252 bajty

przez @ovs

lambda s:reduce(lambda s,a:s.replace(*a),zip(T[2:]+T,T),s)
T="8:9:and allHO1BnoneHT2No1T3Nt2F4Nt3FiveINf4MotherD herself"
for r in "H of theI,4ourI,3hreeI,2woI,1neL:,ILs:,L littleD,D duck,NBonly ,Bbut ".split(','):T=T.replace(r[0],r[1:])
T=T.split(':')

Wypróbuj online!

QuadR , 257 242 bajtów

-14 dzięki Black Owl Kai, -1 dzięki Kevin Cruijssen

ive
Four
hree
Two( little duck)s
One little( duck)
Mother( duck) herself
four
two( little duck)s
only on(e little duck)
but none
and all of the
our
Three
wo
One\1
Mother\1 herself
Five little\1s
three
one\1
none of th\1s
and all
but only four

Wypróbuj online!

Java 10, 347 bajtów

s->{String L=" little duck",M="Mother duck herself";int i=9;for(var t:("ive;Four;hree;Two"+L+"s;One"+L+";four;two"+L+"s;only one"+L+";but none;and all of the;"+M).split(";"))s=s.replace(t,++i+"");for(var t:("Five"+L+"s;but only four;and all;none of the"+L+"s;one"+L+";three;"+M+";One"+L+";wo;Three;our").split(";"))s=s.replace(i--+"",t);return s;}

Wypróbuj online.

Wyjaśnienie:

$[10,21]$

s->{                     // Method with String as both parameter and return-type
  String L=" little duck",M="Mother duck herself";
                         //  Two temp strings to save bytes
  int i=9;               //  Temp replacement integer, starting at 9
  for(var t:("ive;Four;hree;Two"+L+"s;One"+L+";four;two"+L+"s;only one"+L+";but none;and all of the;"+M).split(";"))
                         //  Loop over the parts to replace:
    s=s.replace(t,       //   Replace the part,
                ++i+""); //   with the integer pre-incremented by 1
  for(var t:("Five"+L+"s;but only four;and all;none of the"+L+"s;one"+L+";three;"+M+";One"+L+";wo;Three;our").split(";"))
                         //  Then loop over the parts to replace with in reverse:
    s=s.replace(i--+"",  //   Replace the (post-decrementing) integer,
    t);                  //   with the replacement-part
  return s;}             //  And then return the modified String as result

T-SQL, 407 390 388 382 bajtów

DECLARE @ CHAR(999)=REPLACE(REPLACE('SELECT CASE LEFT(v,2)WHEN''Fi74,''Four''),122,4,''three'')WHEN''Fo74,''Three''),123,5,''two'')WHEN''Th75,''Two''),121,16,''on#'')WHEN''Tw716,''On#''),115,20,''none of th#s'')WHEN''On715,''Mother duck herself''),115,8,''and all'')WHEN''Mo719,''Fiv#s''),113,14,''but only four'')END FROM i',7,'''THEN STUFF(STUFF(v,1,'),'#','e little duck')EXEC(@)

$i$VARCHAR(MAX)$v$

Po kilku zapisanych bajtach REPLACEs wykonuje następujące czynności jako dynamiczny SQL:

SELECT CASE LEFT(v,2)
       WHEN'Fi'THEN STUFF(STUFF(v,1,4,'Four'),122,4,'three')
       WHEN'Fo'THEN STUFF(STUFF(v,1,4,'Three'),123,5,'two')
       WHEN'Th'THEN STUFF(STUFF(v,1,5,'Two'),121,16,'one little duck')
       WHEN'Tw'THEN STUFF(STUFF(v,1,16,'One little duck'),115,20,'none of the little ducks')
       WHEN'On'THEN STUFF(STUFF(v,1,15,'Mother duck herself'),115,8,'and all')
       WHEN'Mo'THEN STUFF(STUFF(v,1,19,'Five little ducks'),113,14,'but only four')END
FROM i

Używa CASEinstrukcji i STUFFpoleceń do wstawiania / zastępowania znaków w wymienionych pozycjach.

EDYCJE :

1. Zastąp oryginał (poniżej) zupełnie inną strategią
2. Zaoszczędzono dwa bajty, przełączając się na LEFTzamiast SUBSTRINGi eliminując spację
3. Zapisano 6 bajtów, zmieniając zmienną CHARi przenosząc dodatkową literę na drugą REPLACE(dzięki, @CDC!)

Oto moja pierwsza wersja, wykorzystująca inną metodę (po wymianie, sformatowana):

DECLARE @ VARCHAR(MAX)
SELECT @=v FROM i
SELECT @=REPLACE(@,PARSENAME(value,2),PARSENAME(value,1))
FROM string_split('e.but none.and all
                  -e.One little duck.Mother duck herself
                  -o.only one little duck.none of the little ducks
                  -o.Two little ducks.One little duck
                  -r.two little ducks.one little duck
                  -r.Three.Two
                  -u.three.two
                  -u.Four.Three
                  -v.four.three
                  -v.Five.Four
                  -t.and all of the.but only four
                  -t.Mother duck herself.Five little ducks','-')
WHERE LEFT(value,1)=SUBSTRING(@,3,1)
PRINT @

STRING_SPLITi PARSENAMEsłużą do dzielenia łańcucha na wiersze i kolumny przez -i .separatory.

Pierwsza kolumna jest kluczowym znakiem, który jest porównywany z trzecią literą wiersza wejściowego (dzięki za pomysł, @ Night2). Drugi i trzeci to zastąpienia dokonywane dla tego wersetu.

Python 2 , 1034 bajty

To jest mój kod! Wykorzystuje prosty słownik. Po uruchomieniu tego kodu możesz wprowadzić dowolny wiersz, a wyświetli on następny wiersz.

PS: Jestem nowy na tym kanale i to jest mój pierwszy post. Naprawdę podobało mi się to wyzwanie, więc postanowiłem spróbować. Prosimy o poprawienie mnie.

import sys
i=sys.stdin.readlines()
s={"Mother":"""Five little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only four little ducks came back.""",
"Five":"""Four little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only three little ducks came back.""",
"Four":"""Three little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only two little ducks came back.""",
"Three":"""Two little ducks went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but only one little duck came back.""",
"Two":"""One little duck went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
but none of the little ducks came back.""",
"One":"""Mother duck herself went out one day,
over the hills and up away.
Mother Duck said, "Quack Quack Quack Quack",
and all of the little ducks came back."""}
print s[i[0].split(" ")[0]]

PHP (7.4), 253 247 bajtów

-6 bajtów poprzez ulepszenie budowy tablicy zamienników dzięki dodatkowej pomocy z „Rozpakowywania wewnątrz tablic”.

<?=strtr($argv[1],array_combine([0,1,...$a=[Five.$l=($o=" little duck").s,($b="but only ").four.$l,Four.$l,$b.three.$l,Three.$l,$b.two.$l,Two.$l,$b.one.$o,One.$o,"but none of the$l","Mother duck herself","and all of the$l"]],[...$a,$a[0],$a[1]]));

Wypróbuj online!

To tworzy tablicę każdego możliwego zamiennika (12 używanych + 2 nieużywane) w key=>valueformacie. Przykład: ['Mother duck herself' => 'Five little ducks', etc...]a następnie po prostu zastępuje te, które używają strtr .

Jedyną interesującą rzeczą jest moje pierwsze użycie „Rozpakowywanie wewnątrz tablic”, które jest nową funkcją w PHP 7.4.

PHP , 264 bajty

<?=str_replace(($a=[[Five.$l=($o=" little duck").s,($b="but only ").four.$l],[Four.$l,$b.three.$l],[Three.$l,$b.two.$l],[Two.$l,$b.one.$o],[One.$o,"but none of the$l"],["Mother duck herself","and all of the$l"]])[$i=strpos(vuroet,($v=$argv[1])[2])],$a[++$i%6],$v);

Wypróbuj online!

W tablicy zapisałem różne słowa każdego wersetu. Odnajduję, który wiersz używa trzeciego znaku wejścia, ponieważ jest on unikalny ( vuroet). Następnie po prostu zastępuję różne słowa tego wersetu innymi słowami następnego wersetu.

Czysty , 352 bajtów

import StdEnv,Text
$n={#"Five"+e+"four"+d,"Four"+e+"three"+d,"Three"+e+"two"+d,"Two"+e+"one"+a,"One"+a+b+"but none"+f,"Mother duck herself"+b+"and all"+f}.[indexOf{n.[2]}"tvuroe"]+" came back."
a=" little duck"
b=" went out one day,\nover the hills and up away.\nMother Duck said, \"Quack Quack Quack Quack\",\n"
d=a+"s"
e=d+b+"but only "
f=" of the"+d

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 262 bajty

x=>$@"{l[g=x[2]*37%724%7]}{g-5:; little} duck{g-4: herself;s;\} went out one day,
{(x=x.Split('\n'))[1]}
{x[2]}
{g-5:and;but} {g-4:all;only;none} {(g>3?"of the":l[g+1].ToLower())} little duc{g%3:ks;;k} came back.";var l=" Four Three Two One Mother".Split();int g

Wypróbuj online!

PowerShell , 356 343 340 336 bajtów

param($p)$l,$M=' little duck','Mother duck herself'
("ive!our;four!three;hree!wo;Four!Three;two!one;s c! c;Two!One;s w! w;only one!none of the;k c!ks c;One$l!$M;but none!and all;$M!Five$l`s;and all of the!but only four"-split';')[$(switch -r($p){^Fi{0,1}^Fo{2,3}^Th{2,4,5}^Tw{6..9}^O{10,11}^M{12,13}})]|%{$p=$p-creplace($_-split'!')}
$p

Wypróbuj online .

Bardziej czytelna wersja:

param($p)
$l, $M = ' little duck', 'Mother duck herself'
$replacements = @"
ive!our
four!three
hree!wo
Four!Three
two!one
s c! c
Two!One
s w! w
only one!none of the
k c!ks c
One$l!$M
but none!and all
$M!Five$l`s
and all of the!but only four
"@ -split '\n'
$i = switch -regex ($p) { ^Fi { 0, 1 }
                          ^Fo { 2, 3 }
                          ^Th { 2, 4, 5 }
                          ^Tw { 6..9 }
                          ^O  { 10, 11 }
                          ^M  { 12, 13 } }
$replacements[$i] | % { $p = $p -creplace ( $_ -split '!' ) }
$p

PowerShell , 265 263 255 251 246 bajtów

$d='Five1four2s,Four1three2s,Three1two2s,Two1one2,One23but none52s,Mother duck herself3and all52s'-split','
'2s34',' little duck',-join($args-split'(\s)')[5..39],'but only ',' of the'|%{$d=$d-replace++$i,$_}
$d[+"$args"[2]*37%724%7]+' came back.'

Wypróbuj online!

Użyłem brutalnej siły, by znaleźć wyraz +"$args"[2]*37%724%7.

 verse | 3rd char. | ASCII code | *37%724%7
-------+-----------+------------+-----------
   0   |    'v'    |     118    |   1
   1   |    'u'    |     117    |   2
   2   |    'r'    |     114    |   3
   3   |    'o'    |     111    |   4
   4   |    'e'    |     101    |   5
   5   |    't'    |     116    |   0

Dzięki @Arnauld za 3rd char.

Japt v2.0a0, 143 bajty

Próbowałem zakodować pojedynczy werset z zamiennikami, ale ostatecznie dostosowanie rozwiązania Arnaulda okazało się krótsze. Mam inny pomysł, który, mam nadzieję, może się powtórzyć krócej, ale nie wiem, kiedy go wypróbuję.

tBn)i`Fr4È(e3
Two4e0
MÇ@r Ýõ Êelf1d a¥23
O01¿t Í
23
TËG4two3
Five4fr3`·g`v`b¢Î)r\dÈ°g[V=` Ò¤ Ýõ`W=Uf/ w.*\n/s `  e`V±'sV+W+`¿t § `]

Spróbuj - zawiera wszystkie wiersze

Bash , 373 355 bajtów

Nie ma tu nic szalonego. Łatwą redukcją kilku bajtów byłoby zastąpienie zmiennych dwuznakowych (a1, a2, a3, e1..e6) zmiennymi jednoznakowymi.

read a{1..3} b
read c
read d
read e{1..6}
W="$e1 $e2"
X="${e3^} $a2 $a3"
Y="$e5 $e6"
Z="$e4 $Y"
p=$X
case $a1 in M*)p="Five ${Y::12}";s="but only four $Y";;O*)p="${d::11} herself";s="and all of $Z";;Tw*)p=${X/s};s="$e1 none of the $a2 ducks $e6";;Th*)s="$W one $e4 duck $e6";;Fo*)s="$W two $Z";;Fi*)s="$W three $Z";;esac
echo $p $b;echo $c;echo $d;echo $s

Wypróbuj online!

Wypróbuj online!

05AB1E , 134 bajty

“€µ‚•„í†ìˆÈ“#’ „ê Ðœs’δJ樅î¥Ðœº¶s‚ìðδJD…€³€É δ쨦“€ƒ€Ÿ€‚€€““€³Šª€‚€€“‚’ „ê Ðœs ’δJ셋邃.δJU.•4Ôāl•|н2èk©è.ª?I„ 
ý#3.$17£ðý„ 
¶:,X®è?

Wypróbuj online!

Ponieważ jestem stosunkowo nowy w 05AB1E, to może być dużo golfa

                ### Preparation of the output strings ###
“€µ‚•„í†ìˆÈ“        push "one two three four five"
#                   split that by spaces
’ „ê Ðœs’           push " little ducks"
δJ                  join each number with " little ducks"
ć¨                  separate "one little ducks" and drop the "s"
…î¥Ðœº¶             push "mother duck herself"
s                   swap it with "one little duck"
‚ì                  prepend both strings to the list ["mother duck herself", "one little duck", "two little ducks" ... ]
ðδJ                 append a space to each list entry
D                   duplicate it
…€³€É               push "but only "
δì                  prepend "but only " to each list entry
¨¦                  drop the first and last list entry
“€ƒ€Ÿ€‚€€“          push "and all of the"
“€³Šª€‚€€“          push "but none of the"
‚                   push the two strings into a list
’ „ê Ðœs ’δJ        append " little ducks " to each
ì                   prepend it to the sentence list ["and all of the little ducks ", "but none of the little ducks ", "but only one little duck " ...]
…‹é‚ƒ.              push "came back."
δJ                  append that to each list entry
U                   save that list in X for later use

                ### Determine which verse has to be answered ###
.•4Ôāl•             push "eoruvt"
|н2è                get the third letter of the input
k                   get the index of that letter in "eoruvt". Now we know which verse we must return
©                   save that index in ® for later use

                ### Print the answer strings ###
è.ª?                print that index of the first sentence list (first three words of answer)
I„                  join the four input strings by <space><newline>
ý
#                   split that by spaces
3.$                 cut off the first three words
17£                 keep only the next 17 words
ðý                  join remaining words by spaces
„ 
¶:                  replace <space><newline> by only <newline>
,                   print that ("went out ... Quack\",") 
X®è?                print the last line of answer

Perl 6 , 247 bajtów

{S:i/ne\sl.*?<(s//}o{m/..(.)(\S*)**3%\s(.**92).*(.**11)/;[(my$l=" little ducks")~$3 XR~"Mother duck herself$2and all of the","One{$l~=$2}but none of the","Five{$l~="but only "}four","Four{$l}three","Three{$l}two","Two{$l}one"]["eotvur".index($0)]}

Wypróbuj online!

Zdecydowanie do gry w golfa, zwłaszcza ostatnie 5 elementów na liście w formularzu "num $l num-1"lub wyrażenie regularne pasujące do właściwych części starego wejścia.

Węgiel drzewny , 156 bajtów

≔⌕tvuroe§θ²δ§⪪”↶0∨↘»≔xj➙⌈´βＸPＮLA‽⟦O⧴＆▷V'¦³≧ψZρ⊞t”¶δＦ‹δ⁵”↶↧V4ⅉＨ‴G%”Ｆ‹δ⁴s⮌…⮌θ¹⁸⸿η⸿ζ⸿§⪪”}∧h⁴ＮＱ≕Q^⪫ΦＧ✂q'ⅉＭG./_⸿s⁵6P⁴″⊟±ＮNpOfBz↷Ｆι‖ＴM→⁻γ？k⁴ς!d⁵º'E,θ}x§-υ”¶δ✂ε±¹¹

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

≔⌕tvuroe§θ²δ

Spójrz na trzeci znak pierwszego wiersza, aby ustalić, którego wersu chcemy.

§⪪”↶0∨↘»≔xj➙⌈´βＸPＮLA‽⟦O⧴＆▷V'¦³≧ψZρ⊞t”¶δＦ‹δ⁵”↶↧V4ⅉＨ‴G%”Ｆ‹δ⁴s⮌…⮌θ¹⁸

Wyjście pierwsza część pierwszej linii przez indeksowanie do listy ciągów Five, Four, Three, Two, One, Mother duck herself. Następnie wydrukuj little ducki, sstosownie do przypadku, a następnie ostatnie 18 znaków wiersza wprowadzania (które są zawsze takie same w każdym wierszu).

⸿η⸿ζ⸿

Dwie środkowe linie są zawsze takie same na każdym wersecie.

§⪪”}∧h⁴ＮＱ≕Q^⪫ΦＧ✂q'ⅉＭG./_⸿s⁵6P⁴″⊟±ＮNpOfBz↷Ｆι‖ＴM→⁻γ？k⁴ς!d⁵º'E,θ}x§-υ”¶δ✂ε±¹¹

W ostatnim wierszu okazuje się, że golfistą jest z jakiegoś powodu dołączenie little ducksdo listy alternatyw, ale ostatnie 11 znaków jest nadal kopiowanych z wejścia.

atrament , 353 bajty

=d(v)
~temp n=(v?"Fi")+(v?"F")*4+(v?"Th")+(v?"T")*2+(v?"O")
{n-1:{n:{n-5:{n-4:{n-3:One|Two}|Three}|Four}|Five} little duck{n-2:s}|Mother duck herself} went out one day,
over the hills and up away,
Mother Duck said "Quack Quack Quack Quack",
{n-1:but {n-2:only {n:{n-5:{n-4:one|two}|three}|four}|none of the}|and all of the} little duck{n-3:s} came back.

Wypróbuj online!

Po pierwsze, zastosowania podciąg kontrole, aby dowiedzieć się, co jesteśmy w wers - to dość łatwe dzięki kapitalizacji numerów na początku - F, Ti Onie występują w innych miejscach, a można wyróżnić drugi i czwarty werset z pierwszy i trzeci, również sprawdzając odpowiednio Fii Th.

Następnie robimy to, co atrament najlepiej, i drukujemy zwykły tekst z tekstem warunkowym. Na początku próbowałem użyć instrukcji switch, ale chociaż wyglądało to ładniej, tak naprawdę zakończyło się to dłużej.
Można by pomyśleć, że Quacks byłoby dobrym miejscem do używania zmiennych, co przy ciągach powtarzanych jako pęczek, ale zmienne mają wystarczająco dużo narzutów, że za każdym razem, gdy próbowałem to zrobić, kod był dłuższy. Może to znak, że nie powinienem grać w atrament.