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.

• recursive: Could you define indeterminate? Could it mean either zero or one?
• hyperneutrino: Please define how randomly this should be generated. Uniform in range or with exponential decline?
• AJFaraday: @recursive Nope, but let's go with a working definition... The program does not consistently present the same number of ducks.
• Mike Hill: Speaking as a Minnesotan, what if mine prints "duck, duck, gray duck" instead? :)
• AJFaraday: @jpmc26 I’m sure there are others. You’d have had to play it with others, for a start.

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

• Etheryte: It always makes me glad when someone uses this on PCG.
• Caimen: Well i forgot this game existed.

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

• Magic Octopus Urn: Oh my lord... Why have I never thought of this.
• Ander Biguri: PVCG (Programming Videogames and Code Golf). Operation Flashpoint was a thing, but WoW? I am waiting the Minecraft and Factorio solutions of this.
• Chris: @AnderBiguri I suspect the Minecraft one would do a little worse than 81 bytes (blocks?) ;)
• gastropner: This should work and get you down to 58 bytes: /run for x=1,random(1,9)do print("Duck")end print("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

enter image description here

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

• BradC: Beautiful. We need more Minecraft in PPCG.
• BradC: Worth mentioning that you (the player) are an entity in the world, so the number of ducks can never be 0 (even if there were no hostile or passive mobs).
• tox123: @BradC there should be entire challenges based around Minecraft.

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

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:

enter image description here

• AJFaraday: This has totally made my day!
• lucasb: I've just realized that you're the same person who proposed that other challenge I linked to. xD Well, I'm glad you liked this! =D
• AJFaraday: Yep, there's some themes in my code golf challenges :) I should definitely give bonus points for pictoral answers.
• MilkyWay90: Isn't this a standard loophole, to get external resources?

Answer 6

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.

• Luis Mendo: disp(['duck '+~pwd';'goose'])? Not sure if this is "indeterminate" enough

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"

• caird coinheringaahing: Welcome to the site, and nice first answer!
• Kevin Cruijssen: Welcome to PPCG! You can golf two bytes by changing ((id(id)%5)+1) to -~(id(id)%5) to get rid of the parenthesis. Tips for golfing in <all languages> and Tips for golfing in Python might be interesting to read through. Enjoy your stay!
• Jonathan Frech: Can id(id) not be id(0) or am I missing something?
• user2699: @Johnathan, looking at id(0) on a couple different computers suggests it's a constant.
• jpmc26: Slightly more intuitive and no more bytes would be to call id([]). This should initialize a distinct list each time the program runs, which in theory should consistently result in different memory addresses.

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.

• Chris: If you change 1+$^T%9 to just $^T, it still works, and you save 4 bytes.
• Ton Hospel: @chris You obviously have more memory than I do. Still, I'll take your suggestion since there are reasonable computers on which it will work. Thanks.

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.

• Steadybox: Welcome to PPCG!
• Chris: You can save one byte by getting rid of the single quotes as long as you replace \n with \\n.
• Digital Trauma: Nice idea. You can do something similar with just bash constructs and no sed for 30 bytes.
• sch: sed s/[0-9]/duck\\n/g<<<$RANDOM\goose can shave off one byte
• tripleee: The sed isn't entirely portable. On some platforms you might get away with a single backslash in \n. On others you won't get a newline no matter what you do.

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.

• Giuseppe: The probability of outputting more than one duck is exp(-1) or around 36.8%.
• Leonhard Euler: It asks to print it on each line. I think you should add " \n" to your "duck"
• user2390246: @stuartstevenson Here I have used a literal newline rather than \n as it is one byte shorter. If you visit the "Try it online!" link you can see that the effect is the same.
• lit: On a DOS/Windows box, that newline would still be two (2) bytes. 0x0d0a

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.

• Olivier Dulac: if we assume you launch a program, it will get a different pid every time. a lot of the time it will be 5 digits long, but not always. hence: change RANDOM to $ to shave 5 bytes?And one could also do a very long string of ducks: yes duck|head -n $$;echo goose
• Digital Trauma: @OlivierDulac yes, I think using $$ is acceptable - thanks!
• Olivier Dulac: you are welcome! I posted my other version (yes duck | head -n $$;echo goose) as an alternative (longer than yours, but one gets a LOT of ducks for 5 extra chars ^^)

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.

• AJFaraday: Congrats! I have literally no idea how this works!
• PunPun1000: @AJFaraday I went ahead and added an explanation for you
• user202729: @PunPun1000 Sorry, but what's the stack? Jelly is a tacit programming language.
• PunPun1000: @user202729 Oops, I got Jelly and 05AB1E messed up in my head, could you please edit it to fix that error? Sorry about that
• MilkyWay90: There's an implicit concatenation in Jelly? Yay!

Answer 13

Ruby, 30 bytes

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

Try it online!

Note: really 31 bytes without the \n cheat.

• AJFaraday: I’m not sure it’s a cheat, strictly speaking.
• epidemian: maybe you could do *(1/rand) to shed 2 bytes. this could fail in the case rand returns 0.0, but that seems astronomically unlikely. or well, i tried 100_000_000.times { puts 'zero!' if rand.zero? } and didn't get a zero, so i'd be OK to deploy this to prod :) (sorry, i deleted a previous comment unintentionally while trying to edit it)
• The Fifth Marshal: @epidemian Answers with extremely small chances of malfunctioning are not allowed

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.

• tripleee: Bash has modulo, though that will increase the size. Try head -n $((1+(RANDOM % 5)))
• Chris: @tripleee Since this is code golf, increasing the size of the output is preferable to increasing that size of the code. And 132767 ducks is downright reasonable compared to the billion or more you see elsewhere ;)
• tripleee: Sure, just hoping to be helpful in case somebody actually wants to apply this groundbreaking research in practice one day. Like, TIO. 44 bytes with some spaces taken out.
• Digital Trauma: @OlivierDulac suggested using $$ instead of $RANDOM for my answer. I think you could use the same to save you 5 bytes. Oh and try sed too: yes duck|sed 1$$q;echo goose
• Digital Trauma: In fact yes duck|sed $$q;echo goose is fine - I don't think your script would ever get a PID < 1.

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

• AJFaraday: That variant sounds pretty fun, and definitely worth a code challenge... I recommend you wait a couple of days and post it as a challenge of your own :)
• Milwrdfan: @AdmBorkBork, this Minnesotan joined this group to just +1 your gray duck.
• TessellatingHeckler: 0..(random)|%{'duck'};'goose' looks like a 29, and will also generate somewhere up to [int]::MaxValue (2.1 billion) ducks before a goose. (And 0..0 does print a duck)
• AdmBorkBork: @TessellatingHeckler Thanks, but I just-now came up with a 28-byte version. :)

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!

• Gymhgy: Really clever use of string formatting!

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

• AJFaraday: So, if I’m reading this right, it reads from left-to-right, bottom-to-top?
• PunPun1000: The language attempts to find a logical truth using just the first line of the program. My program says "Validate the second line, then print goose". Then the second line says "print duck, then validate either a random number 0 to 4 is 0, or validate this line again", so technically left to right just the top line, then any predicates you call from there
• AJFaraday: Cool, it’s so interesting finding out how new languages work. It did reach my inbox, but I’m not sure if it’s because I posed the question or because I’d already commented here.
• Erik the Outgolfer: You can merge the two predicates like this and tie me.

Answer 19

Geometry Dash World 2.2 Editor - 4 objects

Picture of Geometry Dash Level

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.

enter image description here

Goose and 2nd duck don't have a Group ID enter image description here

Inside the random trigger. enter image description here

• Benjamin Urquhart: I sense a theme for this challenge
• MilkyWay90: @BenjaminUrquhart What?
• Benjamin Urquhart: There are submissions for Word of Warcraft, Minecraft, and some other game as well.
• MilkyWay90: @BenjaminUrquhart Better find more games to answer in

Answer 20

05AB1E, (削除) 15 (削除ここまで) 14 bytes

'Ðœ1Ωи`.•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)

• Emigna: You can use 'Ðœ since duck is a single word.
• Magic Octopus Urn: Beats mine: ['ÐœTΩ#].•zíΘ•»
• user2956892: @MagicOctopusUrn I really like your infinite loop approach. Your answer is definitely more in the spirit of the challenge (or what it should have been ?) since it can output an infinite amount of ducks.
• Magic Octopus Urn: @Kaldo still, 15 bytes loses to yours ;)
• Magic Octopus Urn: Alternate 14-byter: 'Ðœ1Ω.D.•zíΘ•»

Answer 21

APL (Dyalog), 22 bytes

1 byte saved thanks to @EriktheOutgolfer

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

Try it online!

• Erik the Outgolfer: Alternative: 'Goose'⊣⎕←⍣(?9)⊢'Duck'

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.

• H.PWiz: Welcome to PPCG! You should be able to use \d over [0-9]. Also, it looks like vim doesn't require the trailing newline, so this can be 45 bytes :)
• Steadybox: Welcome to PPCG!

Answer 24

><>, (削除) 31 (削除ここまで) 22 bytes

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

Try it online!

-9 bytes based on Not a tree's revision

• Emigna: You could remove l?!; and exit with an error.
• Emigna: And you could save some more like this
• Not a tree: Or like this.
• Suppen: @Notatree I get that one to sometimes print "\nkcud\nkcud...". It rarely behaves correctly
• KSmarts: @Suppen Just using an arrow instead of a mirror fixes it; see edit.

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

• Jo King: You don't need the # on the second line
• Jo King: And "technically", whitespace within a line is fine so you can cut out a couple of quotes (even if the output looks weird)
• Vincent: @JoKing Thanks, see my edit.

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

• BradC: Nice. Down to 61 if you change select to print and replace the final 'duck'select'goose' with 'duck(linebreak)goose' (with a literal linebreak, of course)
• BradC: Actually, you can just do while rand()<.5print'duck'print'duck(linebreak)goose' for 43.
• Probably: Nice, thanks @BradC. Is there another way to represent a line break in a string other than adding a char(13)?
• BradC: Yep, just literally put a return inside the quotes, I'll edit your post to show you (comments don't show returns).
• BradC: Save 3 more bytes: change the first while to if. Prints (randomly) either one duck or two, which (I believe) still satisfies the challenge.

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"

• AdmBorkBork: You shouldn't need the $ in front of (Random). Try it online!
• SomeShinyObject: @AdmBorkBork thanks for the catch!

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ṙ+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!