Duck, duck, goose!

Question

Remember the kids game, 'Duck, Duck, Goose'? No? Me neither.

The challenge

• Print the word 'duck' on individual lines an indeterminate amount of times.
• Print the word 'goose'.
• Your program ends.

The rules

• Attempt to play the game in the fewest bytes.
• There must be at least one duck.
• There must be exactly one goose, at the end of the list.
• There must be exactly one bird on each line. No empty lines.
• The case of the outputted strings is irrelevant.
• White-space within a line is fine.
• Your program must finish.
• Your program must not consistently produce the same number of ducks.

Have fun!

---

Please note: This question is not a duplicate of Shortest code to produce non-deterministic output

Reasons include:

• The association to a childrens' game
• The defined start and end requirements of the result string. There is no specified output in the other challenge.
• Answers For the other, non-duplicate challenge are in a single-digit number of bytes. The average for this one is around 30, or there about.
• By the amount of overlap between this challenge and that one, any code-golf question including the 'random' tag is a duplicate. Should we delete them all?
• The code answers for this challenge would match the other challenge (in a ridiculously bloated way), but the answers to that challenge would not match this one.

Answer 1

Operation Flashpoint scripting language, 48 bytes

f={s="duck\n";s+([s,""]select random 1)+"goose"}

Always prints either one or two ducks.

random 1 returns a (floating point) number between 0 and 1. That number is passed as an argument to select along with the array [s,""]. The random number is then rounded to the nearest integer (either 0 or 1), and the array element at that index is selected from the array.

Call with:

hint call f

Output:

Alternative 56 bytes version:

f={s="duck\n";format[s+"%1goose",[s,""]select random 1]}

Answer 2

World of Warcraft 81 Bytes

Here's a macro that you can run in World of Warcraft.

/run for x=1,random(1,9) do SendChatMessage("Duck") end; SendChatMessage("Goose")

Answer 3

Minecraft <1.13, 72 54 bytes

Sorry, I had to.

Instructions:

• Create a new Minecraft world in Creative Mode
• Find the save folder for that world, and place the following code in data/functions/minecraft/ddg.mcfunction
• Run /function ddg in the game console

How it works:

Outputs the word "duck" for every entity in the world, then outputs the word "goose". Since entities are constantly spawning and despawning, the number of "duck"s will not be consistent. I used tellraw instead of the much shorter say because say outputs the name of the entity, while tellraw outputs exactly what it is told.

execute @e ~ ~ ~ tellraw @a "duck"
tellraw @a "goose"

Screenshot

Edit: Changed {"text":"duck"} to just "duck" (and the same with "goose")

Answer 4

JavaScript, 45 44 42 39 37 bytes

Has the potential to produce an overflow error.

f=_=>`duck
${new Date%2?f():`goose`}`

---

Test it

o.innerText=(
f=_=>`duck
${new Date%2?f():`goose`}`
)()

<pre id=o></pre>

Answer 5

Octave, 38 33 bytes

This is not the shortest (it's 36 bytes), but it's my favorite. The explanation is in the bottom.

disp(['duck '+~(1:1/rand)';'goose'])

Try it online!

---

Some shorter variations:

This works in principle (33 bytes), but the online interpreters times out:

disp(['duck '+~(1:now)';'goose'])

Adding some bytes to make the output shorter makes it 35 or 36 bytes:

disp(['duck '+~(7e5:now)';'goose'])   % Works on octave-online.net
disp(['duck '+~(7.3e5:now)';'goose']) % Works on tio.run

Explanation:

I'll just explain the last random one. The others are similar, but uses the number of days since January 1st, 0000 until today.

rand returns a random number on the interval (0, 1). Thus, 1/rand returns a number larger than 1. Since a range 1:f, where f is a random float larger than 1 is identical to 1:floor(f), 1:1/rand creates a range 1 .. x, where x >= 1.

I'll try to explain this as if Octave was a stack based language.

      'duck '                           % Push the string 'duck ' to the stack
               (1:1/rand)               % Push a vector 1... floor(1/rand)
              ~(1:1/rand)'              % Negate the vector (making it all zeros)
                                        % and transpose it.
             +                          % Add 'duck ' with the vertical vector of zeros
                                        % to implicitly duplicate the string r times
     [                    ;'goose']     % Push the string 'goose' and concatenate
                                        % vertically with the rest
disp(                              )    % Display it all.

Answer 6

Z Shell (+ wget & Netpbm), 168 160 150 148 145 135 120 bytes

d(){wget -O- bit.ly/$1|jpegtopnm|pamscale -w 64 -h 64};d DckDkGo|pnmtile 64 $[(RANDOM&7+1)*64]|pnmcat -tb - <(d g005eGG)

Not the shortest solution, but I felt like giving a twist of sorts to this challenge (inspired by @AlexG's solution to this other problem).

This script generates a PPM image containing between 1-8 pictures of ducks and a picture of a goose at the bottom on standard output. It downloads the two source pictures from Wikipedia, so internet access is necessary for it to work.

Sample output converted to JPEG through pnmtojpeg:

Answer 7

Python 2, 36 34 bytes

print"duck\n"*((id(id)%5)+1),"goose"

Try It Online!

Suggestion by Kevin Cruijssen gets us to 34 bytes:

print"duck\n"*-~(id(id)%5),"goose"

Answer 8

Perl 5, 20 bytes

First a practical 26 bytes:

Ducks 1 to 9 times before being goosed.

say"Duck
"x(1+$^T%9),Goose

Try it online!

But if you have lots of memory and time this 20 byte version (as suggested by Chris) works too:

say"Duck
"x$^T,Goose

This also assumes the Year 2038 Problem will be solved for Perl 5, otherwise it will be invalid for 1 second 20 years hence.

Answer 9

Bash, 39 38 37 bytes

sed s/[0-9]/duck\\n/g<<<$RANDOM\goose

Try it online!

Prints a number of ducks equal to the number of digits in an integer uniformly distributed on [0,32767] (so, more often than not, five ducks (a good number of ducks)).

-1 byte each thanks to @Chris and @sch pointing out pairs of quotes that weren't pulling their weight.

Answer 10

R, 35 bytes

cat(rep("duck
",rexp(1)+1),"goose")

Try it online!

rexp() produces a random number from an exponential decay function. +1 to ensure at least one duck. All lines after the first include a leading space (which is the default separator for cat) but this is allowed.

Answer 11

Pure Bash (no external utilities), 25

Based on @SophiaLechner's answer, this also prints a good number of ducks.

@OlivierDulac's idea to use the script shell PID as stored in the $ parameter saves 5 bytes.

echo "${$//?/duck
}"goose

Try it online.

Answer 12

Jelly, 13 bytes

2X“¢;ÆS»ẋ“ʋ¢»

Try it online!

Explanation:

2X“¢;ÆS»ẋ“ʋ¢»

2X             Random number (1 or 2)
  “¢;ÆS»       Compressed string equivalent to "duck\n"
        ẋ      Repeat the "duck\n" that random number of times
         “ʋ¢»  Compresses string equivalent to "goose"
               Implicitly concatenated and returned

---

More readable version: Try it online!

Will always return 1 or 2 ducks.

Answer 13

Ruby, 30 bytes

puts"duck
"*rand(1..9)+"goose"

Try it online!

Note: really 31 bytes without the \n cheat.

Answer 14

Bash + Coreutils, 36 27 bytes

yes duck|sed $$q;echo goose

Prints too many ducks (between 2 and cat /proc/sys/kernel/pid_max), then one goose.

Saved nine bytes thanks to Digital Trauma and Olivier Dulac.

Try it online! (but keep in mind that it may get truncated occasionally)

Same length, but with no echo:

yes duck|sed $${agoose'
q}'

Try it online!

a is the append command in sed, and q quits. Both only run on the line $$, which corresponds to the PID.

Answer 15

PowerShell, 35 30 28 bytes

,"duck"*((Random)+1)
"goose"

Try it online! (modified version)

Generates an array of Get-Random number of items. It might take a while. This adds a +1 to ensure we get at least one duck. The modified version also includes a -maximum flag of 5 so you can see the program works as expected (the modified version will print 1, 2, 3, or 4 ducks before the goose).

The array and the solitary goose string is left on the pipeline, and the implicit Write-Output gives us newline-separated values for free.

You don't know how difficult it was for me to not change the last line to "gray duck" ...

Answer 16

Python 2, 54 bytes

from random import*
print"duck\n"*randint(1,9)+"goose"

Try It Online!

Answer 17

C# (Visual C# Interactive Compiler), 55 bytes

Write("{"+new Random().Next(2)+"}{0}goose","duck\n","")

Try it online!

Answer 18

Brachylog, 24 21 bytes

-3 bytes thanks to Erik the Outgolfer

"duck"ẉ4ṙ0∧"goose"w∨↰

Try it online!

In celebration of the Language of the month, my first brachylog post. The control flow in this language is cool.

How it works:

"duck"ẉ4ṙ0∧"goose"w∨↰
"duck"ẉ                 print duck with a new line
       4ṙ               choose a random number in the range is [0, 4]
         0              verify it equals zero
          ∧             and (short circuits)
           "goose"w     print goose without a newline
                   ∨    or (if it did not equal zero)
                    ↰   repeat the procedure

Answer 19

Geometry Dash World 2.2 Editor - 4 objects

Explanation:

The BG trigger is the current 2.2's random trigger, so it either toggles the Group ID 1 or 2.

The first "DUCK" has a group id of 1, which makes it have a 50% chance of being removed or not (toggled).

There is no object with the Group ID 2 in this level, so there is a 50% chance of 2 "DUCK"s being displayed.

How to Reproduce this:

The first "DUCK" has a Group ID of 1.

Goose and 2nd duck don't have a Group ID

Inside the random trigger.

Answer 20

05AB1E, 15 14 bytes

'Ðœ₁Ωи`.•zíΘ•»

Try it online!

Will print 2, 5 or 6 ducks and then goose.

-1 byte thanks to @Emigna using ' for a single compressed word (duck)

Answer 21

APL (Dyalog), 22 bytes

1 byte saved thanks to @EriktheOutgolfer

'Goose'⍪⍨(?9)5⍴'Duck '

Try it online!

Answer 22

Retina, 17 bytes

?\\K`duck
K`goose

Try it online!

Try it online!

Prints 1 or 2 ducks, with equal probability.

Explanation

?\\K`duck

Set the working string to duck and print it with a trailing linefeed (\). Then this is wrapped in another output stage, but this one has the random flag (?) applied to it, so it only prints with a probability of 50%.

K`goose

Replace the duck with goose, which is printed implicitly at the end of the program.

Here's a fun alternative which prints 1 duck with 50% probability, 2 ducks with 25%, 3 ducks with 12.5%...:

\K`duck
?+\G`
K`goose

Answer 23

Vim (script) on Linux, 46 43 bytes (49 46 with : at start of line)

.!date +0\%N\%s6
s/6.*/goose
s/\d/duck\r/g

Executed as vim -S filename or pasted into running vim with : before each line.

Answer 24

><>, 31 22 bytes

"duck"a>x
r"esoog"<>o<

Try it online!

-9 bytes based on Not a tree's revision

Answer 25

Befunge 98, 38 30 25 bytes

"esooG"v>:#,_@
"Duck"a<?<

Try it online!

• Thanks @JoKing for stripping the useless trampoline
• Switching to Befunge 98 for shorter new line - now Duck fits within a single string

Answer 26

T-SQL, 70 44 43 bytes (Many ducks)

while rand()<.9print'duck'print'duck
goose'

Thanks @Zac Faragher!

Revised Version, 54 43 40 bytes (1 or 2 ducks)

Thanks @BradC!

if rand()<.5print'duck'print'duck
goose'

I can't seem to get this to run properly in SQL Fiddle, but it works just fine in LINQPad and SSMS.

Not sure if this is a known limitation of SQL Fiddle or I'm just doing something wrong

Answer 27

Powershell - 31 30 bytes

Warning: You're most likely going to end up with a lot of ducks. Random includes the values of 0 to Int32.MaxValue so, depending on how random you're number is, this could be a lot of quacking.

1..(Random)|%{"Duck"};"Goose"

Answer 28

Fission, 24 19 bytes

R"duck"N#
"goose"*[

Try it online!

-5 bytes thanks to Martin Ender

Answer 29

Brachylog, 21 bytes

1ṙ+₁;"Duck
"j₍,"Goose

Try it online!

Hey, language of the month going inactive, let's kick things up a little!

Answer 30

Pure Bash, 41 37 bytes

printf %s\\n ${RANDOM//[0-9]/duck } goose

This uses the same trick as in Sophia Lechner's answer to obtain a random number in the range 0-32767 with $RANDOM but does not require sed or any other external utilities to be installed to transform it into the desired result.

The Bash parameter expansion ${variable//pattern/replacement} obtains the value of variable with any match on pattern replaced by replacement. The shell then expands and tokenizes the arguments to printf, which applies the format string to each resulting argument.

I'm not a good golfer. Digital Trauma's answer has a much more lenient pattern which gets me down to 37 bytes.

printf %s\\n ${RANDOM//?/duck } goose

Try it online!