[Question]
  [
So, last week I posted a challenge to play [Duck, Duck, Goose](https://codegolf.stackexchange.com/questions/157897/duck-duck-goose). This lead to a number of Minnesotans commenting about their regional ['Gray duck' variation](https://en.wikipedia.org/wiki/Duck,_duck,_goose#Duck,_Duck,_Gray_Duck).
So here's the rules:
Using this list of colours:
```
Red
Orange
Yellow
Green
Blue
Indigo
Violet
Gray
```
Write a program to follow these rules:
1. Select one of these colours, and prepend it to the word 'duck' and print the result to a new line.
2. If the colour was not 'Gray', repeat step 1.
3. If the colour was 'Gray', end your program.
Rules which must be followed:
* The program should not consistently print the same number of lines.
* It can begin on 'Gray duck', but should not do consistently.
* There should be exactly one duck on each line and no empty lines are output.
* There should be at least one space between a colour and a duck.
* White space before and after the significant output does not matter.
* The case of the output doesn't matter.
* Colours can be repeated.
* The output doesn't have to contain every colour every time, but it must be possible that your code will output every colour.
* No colours outside the above array can be included.
* Either grey or gray are acceptable in your answer.
* Colours should not consistently be in the same order.
* Aim for the shortest program. Smallest number of bytes wins.
Example output:
```
Green duck
Orange duck
Yellow duck
Indigo duck
Yellow duck 
Gray duck
```
Thanks to @Mike Hill for first alerting me to this variation.
  
[Answer]
## LuaLaTeX, 220 211 characters
command:
```
lualatex -interaction nonstopmode
```
Not the shortest, but the fanciest. Based on [@skillmon's solution](https://codegolf.stackexchange.com/a/159706/79196)
[![enter image description here](https://i.stack.imgur.com/p4dBo.png)](https://i.stack.imgur.com/p4dBo.png)
```
\RequirePackage{tikzducks}\newcount\b\let~\def~\0{red}~\1{orange}~\2{yellow}~\3{green}~\4{blue}~\5{cyan}~\6{violet}~\7{gray}\loop\b\uniformdeviate8\tikz\duck[body=\csname\the\b\endcsname]; \ifnum\b<7\repeat\stop
```
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) (C64), 124 bytes
```
00 C0 AD 12 D0 85 02 A2 17 8E 18 D0 A5 02 F0 03 0A 90 02 49 1D 85 02 A8 CA 10
02 A2 2F BD 42 C0 D0 F6 88 D0 F3 86 FB E8 BD 42 C0 F0 06 20 16 E7 E8 D0 F5 AA
BD 73 C0 F0 06 20 16 E7 E8 D0 F5 A6 FB D0 C9 60 00 C7 52 45 59 00 D2 45 44 00
CF 52 41 4E 47 45 00 D9 45 4C 4C 4F 57 00 C7 52 45 45 4E 00 C2 4C 55 45 00 C9
4E 44 49 47 4F 00 D6 49 4F 4C 45 54 00 20 44 55 43 4B 0D 00
```
**[Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22duck.prg%22:%22data:;base64,AMCtEtCFAqIXjhjQpQLwAwqQAkkdhQKoyhACoi+9QsDQ9ojQ84b76L1CwPAGIBbn6ND1qr1zwPAGIBbn6ND1pvvQyWAAx1JFWQDSRUQAz1JBTkdFANlFTExPVwDHUkVFTgDCTFVFAMlORElHTwDWSU9MRVQAIERVQ0sNAA==%22%7D,%22vice%22:%7B%22-autostart%22:%22duck.prg%22%7D%7D)** -- Usage: `SYS49152`.
[![screenshot](https://i.stack.imgur.com/Ibyb1.png)](https://i.stack.imgur.com/Ibyb1.png)
---
### Explanation (commented disassembly):
```
         00 C0       .WORD $C000        ; load address
.C:c000  AD 12 D0    LDA $D012          ; current rasterline as seed
.C:c003  85 02       STA $02            ; to "random" value
.C:c005  A2 17       LDX #$17           ; cfg for upper/lower, also use as
.C:c007  8E 18 D0    STX $D018          ;    initial index into colors array
.C:c00a   .loop:
.C:c00a  A5 02       LDA $02            ; load current random val
.C:c00c  F0 03       BEQ .doEor         ; zero -> feedback
.C:c00e  0A          ASL A              ; shift left
.C:c00f  90 02       BCC .noEor         ; bit was shifted out -> no feedback
.C:c011   .doEor:
.C:c011  49 1D       EOR #$1D
.C:c013   .noEor:
.C:c013  85 02       STA $02            ; store new random val
.C:c015  A8          TAY                ; use as counter for next color string
.C:c016   .findloop:
.C:c016  CA          DEX                ; next char pos in colors (backwards)
.C:c017  10 02       BPL .xok           ; if negative ...
.C:c019  A2 2F       LDX #$2F           ;    load length of colors - 1
.C:c01b   .xok:
.C:c01b  BD 42 C0    LDA .colors,X      ; load character from colors
.C:c01e  D0 F6       BNE .findloop      ; not zero, try next character
.C:c020  88          DEY                ; decrement random counter
.C:c021  D0 F3       BNE .findloop      ; not zero, continue searching
.C:c023  86 FB       STX $FB            ; save character position
.C:c025  E8          INX                ; increment to start of color
.C:c026   .outloop:
.C:c026  BD 42 C0    LDA .colors,X      ; output loop for color string
.C:c029  F0 06       BEQ .duckout
.C:c02b  20 16 E7    JSR $E716
.C:c02e  E8          INX
.C:c02f  D0 F5       BNE .outloop
.C:c031   .duckout:
.C:c031  AA          TAX                ; A is now 0, use as char pos for duck
.C:c032   .duckoutloop:
.C:c032  BD 73 C0    LDA .duck,X        ; output loop for duck string
.C:c035  F0 06       BEQ .outdone
.C:c037  20 16 E7    JSR $E716
.C:c03a  E8          INX
.C:c03b  D0 F5       BNE .duckoutloop
.C:c03d   .outdone:
.C:c03d  A6 FB       LDX $FB            ; load saved character position
.C:c03f  D0 C9       BNE .loop          ; not zero -> continue main loop
.C:c041  60          RTS                ; zero was start of "Grey" -> done
.C:c042   .colors:
.C:c042  00 c7 52 45    .BYTE 0, "Gre"
.C:c046  59 00 d2 45    .BYTE "y", 0, "Re"
.C:c04a  44 00 cf 52    .BYTE "d", 0, "Or"
.C:c04e  41 4e 47 45    .BYTE "ange"
.C:c052  00 d9 45 4c    .BYTE 0, "Yel"
.C:c056  4c 4f 57 00    .BYTE "low", 0
.C:c05a  c7 52 45 45    .BYTE "Gree"
.C:c05e  4e 00 c2 4c    .BYTE "n", 0, "Bl"
.C:c062  55 45 00 c9    .BYTE "ue", 0, "I"
.C:c066  4e 44 49 47    .BYTE "ndig"
.C:c06a  4f 00 d6 49    .BYTE "o", 0, "Vi"
.C:c06e  4f 4c 45 54    .BYTE "olet"
.C:c072  00             .BYTE 0
.C:c073   .duck:
.C:c073  20 44 55 43    .BYTE " duc"
.C:c077  4b 0d 00       .BYTE "k", $d, 0
```
[Answer]
## [Perl 5](https://www.perl.org/), 79 bytes
```
say$_=(Grey,Red,Orange,Yellow,Green,Blue,Indigo,Violet)[rand 8]." duck"until/y/
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVIl3lbDvSi1UicoNUXHvygxLz1VJzI1Jye/XAconJqn45RTmqrjmZeSmZ6vE5aZn5NaohkNVJaiYBGrp6SQUpqcrVSaV5KZo1@p////v/yCksz8vOL/ur6megaGBgA "Perl 5 – Try It Online")
[Answer]
# [Taxi](https://bigzaphod.github.io/Taxi/), 1995 bytes
```
Go to Heisenberg's:w 1 r 3 r 1 l.[a]Pickup a passenger going to Divide and Conquer.8 is waiting at Starchild Numerology.8 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 3 l 1 l 3 l.Pickup a passenger going to Divide and Conquer.Pickup a passenger going to Multiplication Station.Go to Divide and Conquer:w 1 r 3 r 1 r 2 r 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:e 1 l 1 l 2 l.Pickup a passenger going to What's The Difference.Pickup a passenger going to Trunkers.Go to Zoom Zoom:n.Go to Trunkers:w 3 l.Pickup a passenger going to What's The Difference.Go to What's The Difference:w 2 r 1 l.Pickup a passenger going to Multiplication Station.1 is waiting at Starchild Numerology.Go to Starchild Numerology:e 1 r 1 l 3 l.Pickup a passenger going to Addition Alley.Go to Multiplication Station:w 1 r 2 r 1 r 4 l.Pickup a passenger going to Addition Alley.Go to Addition Alley:n 2 l 1 r 3 l 1 l.Pickup a passenger going to The Underground.'Red duck\n' is waiting at Writer's Depot.'Orange duck\n' is waiting at Writer's Depot.'Yellow duck\n' is waiting at Writer's Depot.'Green duck\n' is waiting at Writer's Depot.'Blue duck\n' is waiting at Writer's Depot.'Indigo duck\n' is waiting at Writer's Depot.'Violet duck\n' is waiting at Writer's Depot.'Grey duck' is waiting at Writer's Depot.Go to Writer's Depot:n 1 l 1 l.[b]Pickup a passenger going to Narrow Path Park.Go to Narrow Path Park:n 3 r 1 l 1 r.Go to The Underground:e 1 r.Switch to plan "c" if no one is waiting.Pickup a passenger going to The Underground.Go to Writer's Depot:s 2 r 1 l 2 l.Switch to plan "b".[c]Go to Narrow Path Park:n 4 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 r 4 r 1 l.Go to Writer's Depot:s 1 r 1 l 2 l.Switch to plan "a" if no one is waiting.[d]Pickup a passenger going to Sunny Skies Park.Go to Sunny Skies Park:n 2 r.Go to Writer's Depot:n 1 l.Switch to plan "e" if no one is waiting.Switch to plan "d".[e]Go to Heisenberg's:n 3 r 3 r.Switch to plan "a".
```
[Try it online!](https://tio.run/##pVXBbtswDP0VIhffDCTpocita4Fuh7VB063YshwUi7EJq5JHy8vy9Zlsy0XiOo6bHWwh1DP5yEcyVvyl/f7egDXwGSlHvUaOg3y2hTEwTN0zBhUuxWpOUVpkICATuYPFyBAb0nH55R39IYkgtIRbo38XyOE1UA5bQbaECAsLKzhKSEl4KF6RjTLxbhioJtd1NdMlOUdSNWf4QZZ98K@FspQpioQlo0sC5enpvPd1VDGGSX32RrjdRcpo9C79rxlWyZTP5ExCL4mwQQ7PCTo@mw0y6gh7v3jmQqfIuQ/505jX6jVr8moALpvpRdFrN513zufE99MFdR//Z69gJcuQPrmRkqrQN0ph47OblRfdiw1Xl3g@NrqenlTyc9PX/YK6Cn/T0s0sm0LLMHhCCbKI0l86aBXshckiO1XuMDM2DB5ZOF8DwT9QKbMdCL5nRD0Q@0kVQzl80ZJiMxD8nYxCO5zwroKeAfrmPjL6JVRtyXXvlnwQzK6Gc2ET9@LUu2ubnUO/dqsF4ufyWOe6m8PFlmyUlPeZEhpG0QhoA9qA2yMHmXyogzpzzJvJrXZSO@x6FC6j1clszk3F3OQWHjcbelsfBxY/t1d@cZxgN@5hJ04UZSl71VoUWu9gkRLmh2q1zdW8ck9nvOODJ/i0cdJVFVcdf811f0w79BejcL//Bw "Taxi – Try It Online")
I think it's worth noting that 47% of this code is just picking a random integer from 1 to 8.  
Also, Taxi is so verbose that it is way shorter to hard code the `duck\n` after each color rather than concatenating it later.  
Here's the un-golfed version:
```
Go to Heisenberg's: west 1st right 3rd right 1st left.
[Pick up a random INT 1-8 going to The Underground]
[a]
Pickup a passenger going to Divide and Conquer.
8 is waiting at Starchild Numerology.
8 is waiting at Starchild Numerology.
Go to Starchild Numerology: north 1st left 3rd left 1st left 3rd left.
Pickup a passenger going to Divide and Conquer.
Pickup a passenger going to Multiplication Station.
Go to Divide and Conquer: west 1st right 3rd right 1st right 2nd right 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: east 1st left 1st left 2nd left.
Pickup a passenger going to What's The Difference.
Pickup a passenger going to Trunkers.
Go to Zoom Zoom: north.
Go to Trunkers: west 3rd left.
Pickup a passenger going to What's The Difference.
Go to What's The Difference: west 2nd right 1st left.
Pickup a passenger going to Multiplication Station.
1 is waiting at Starchild Numerology.
Go to Starchild Numerology: east 1st right 1st left 3rd left.
Pickup a passenger going to Addition Alley.
Go to Multiplication Station: west 1st right 2nd right 1st right 4th left.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: north 2nd left 1st right 3rd left 1st left.
Pickup a passenger going to The Underground.
[Use the random INT to select a color]
'Red duck\n' is waiting at Writer's Depot.
'Orange duck\n' is waiting at Writer's Depot.
'Yellow duck\n' is waiting at Writer's Depot.
'Green duck\n' is waiting at Writer's Depot.
'Blue duck\n' is waiting at Writer's Depot.
'Indigo duck\n' is waiting at Writer's Depot.
'Violet duck\n' is waiting at Writer's Depot.
'Grey duck' is waiting at Writer's Depot.
Go to Writer's Depot: north 1st left 1st left.
[b]
Pickup a passenger going to Narrow Path Park.
Go to Narrow Path Park: north 3rd right 1st left 1st right.
Go to The Underground: east 1st right.
Switch to plan "c" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Writer's Depot: south 2nd right 1st left 2nd left.
Switch to plan "b".
[Output the selected color]
[c]
Go to Narrow Path Park: north 4th left.
Pickup a passenger going to Post Office.
Go to Post Office: east 1st right 4th right 1st left.
[If the color was grey, exit by error]
Go to Writer's Depot: south 1st right 1st left 2nd left.
Switch to plan "a" if no one is waiting.
[Get rid of the rest of the colors]
[You could throw them off a bridge but you won't get paid]
[d]
Pickup a passenger going to Sunny Skies Park.
Go to Sunny Skies Park: north 2nd right.
Go to Writer's Depot: north 1st left.
Switch to plan "e" if no one is waiting.
Switch to plan "d".
[Start over from the beginning]
[e]
Go to Heisenberg's: north 3rd right 3rd right.
Switch to plan "a".
```
[Answer]
# [Java (OpenJDK 9)](http://openjdk.java.net/projects/jdk9/), 133 bytes
```
v->{for(int x=9;x>0;)System.out.println("Grey,Red,Orange,Yellow,Green,Blue,Indigo,Violet".split(",")[x+=Math.random()*8-x]+" duck");}
```
[Try it online!](https://tio.run/##HY69asMwFIV3P8XFk5XIomODaw/tUDqEQgOBEjKosuzIkSUhXbkOwc/uqpkOfOeHM/CJl9ZJM7TX3apGZz3CkCCLqDTrohGorGGbKhOahwB7rgzcMwAXf7QSEJBjksmqFsbkFQf0yvSnM3DfB/KIArxZE@Io/csx5RrooF6nsrl31hfKIMz1rpqbp4ocbgHlyGxE5tIMalPk717e6Jds6afnppf0W2ptf2nC0tBXHSX9MK3qLT0qqyXmLDitsMhpTk7ztt5zvLDUbO1YkM1zOZ@3ObRRXHNSLWv1uNcxLoR0WJioNflnS7asfw "Java (OpenJDK 9) – Try It Online")
## Explanations
```
v->{                              // Void-accepting void lambda function
  for(int x=9;x>0;)               //  Loop until x is zero
    System.out.println(           //   Print...
        "Grey,Red,Orange,         //       colors, "Grey" first
         Yellow,Green,Blue,       //          more colors
         Indigo,Violet"           //          more colors
        .split(",")               //       as an array
          [x+=Math.random()*8-x]  //       pick one randomly, use implicit double to int cast with "x+=<double>-x" trick
        +" duck");                //      Oh, and append " duck" to the color.
}
```
[Answer]
# [Operation Flashpoint](https://en.wikipedia.org/wiki/Operation_Flashpoint:_Cold_War_Crisis) scripting language, 133 bytes
```
f={s="";v=s;while{v!="grey"}do{v=["Red","Orange","Yellow","Green","Blue","Indigo","Violet","Grey"]select random 7;s=s+v+" duck\n"};s}
```
**Call with:**
```
hint call f
```
**Example output:**
[![](https://i.stack.imgur.com/bnkbn.jpg)](https://i.stack.imgur.com/bnkbn.jpg)
At first I somehow misread the challenge as if the goal was to just output a varying amount of lines, not necessarily ending at the "Grey duck" -line. Following that incorrect interpretation produced a slightly more interesting piece of code:
```
f={s="";c=[1];c set[random 9,0];{s=s+(["Red","Orange","Yellow","Green","Blue","Indigo","Violet","Grey"]select random 7)+" duck\n"}count c;s}
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~93 91 90 89 87 86~~ 85 bytes
Thanks to [Dom Hastings](https://codegolf.stackexchange.com/users/9365/dom-hastings) for saving 2 bytes, [Kirill L.](https://codegolf.stackexchange.com/users/78274/kirill-l) 1 byte and [Asone Tuhid](https://codegolf.stackexchange.com/users/77598/asone-tuhid) 1 byte!
```
puts %w(Red Orange Yellow Green Blue Indigo Violet Grey)[$.=rand(8)]+" duck"while$.<7
```
[Try it online!](https://tio.run/##KypNqvz/v6C0pFhBtVwjKDVFwb8oMS89VSEyNScnv1zBvSg1NU/BKac0VcEzLyUzPV8hLDM/J7UEJFGpGa2iZwtUnqJhoRmrraSQUpqcrVSekZmTqqJnY/7/PwA "Ruby – Try It Online")
[Answer]
# pdfTeX, 231 220 219 209 207 bytes
```
\newcount\b\let~\def~\0{Red}~\1{Orange}~\2{Yellow}~\3{Green}~\4{Blue}~\5{Indigo}~\6{Violet}~\7{Gray}~\9{ }\newlinechar`z\loop\b\pdfuniformdeviate8\message{z\csname\the\b\endcsname\9duck}\ifnum\b<7\repeat\bye
```
# LuaTeX, 216 ~~206~~ 204 bytes
```
\newcount\b\let~\def~\0{Red}~\1{Orange}~\2{Yellow}~\3{Green}~\4{Blue}~\5{Indigo}~\6{Violet}~\7{Gray}~\9{ }\newlinechar`z\loop\b\uniformdeviate8\message{z\csname\the\b\endcsname\9duck}\ifnum\b<7\repeat\bye
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~42~~ 40 bytes
Saved 2 bytes thanks to *Erik the Outgolfer*
```
[“ëßigo°¯†¾›ÈŠÛˆ¨‡—°Íolet“#7ÝΩ©è'Ðœðý,®#
```
[Try it online!](https://tio.run/##AVMArP8wNWFiMWX//1vigJzDq8OfaWdvwrDCr@KAoMK@4oC6w4jFoMOby4bCqOKAoeKAlMKww41vbGV04oCcIzfDnc6pwqnDqCfDkMWTw7DDvSzCriP//w "05AB1E – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 68 bytes
```
"Grey","
Red
Orange
Yellow
Green
Blue
Indigo
Violet"ṇṛS," duck"ẉS¬?↰
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/X8m9KLVSSUeJKyg1hcu/KDEvPZUrMjUnJ7@cCyiTmsfllFOayuWZl5KZns8Vlpmfk1qi9HBn@8Ods4N1lBRSSpOzlR7u6gw@tMb@UduG//8B "Brachylog – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~84~~ 81 bytes
Thanks to Dom Hastings for -3 bytes.
```
puts$_=%w[Red Orange Yellow Green Blue Indigo Violet Grey].sample+" duck"until/y/
```
[Try it online!](https://tio.run/##KypNqvz/v6C0pFgl3la1PDooNUXBvygxLz1VITI1Jye/XMG9KDU1T8EppzRVwTMvJTM9XyEsMz8ntQQkURmrV5yYW5CTqq2kkFKanK1UmleSmaNfqf//PwA "Ruby – Try It Online")
[Answer]
# Bash + GNU utilities, 72
```
shuf -e {Red,Orange,Yellow,Green,Blue,Indigo,Violet,Grey}\ Duck|sed /y/q
```
[Try it online](https://tio.run/##S0oszvj/vzijNE1BN1WhOig1Rce/KDEvPVUnMjUnJ79cx70oNTVPxymnNFXHMy8lMz1fJywzPye1BCRRWRuj4FKanF1TnJqioF@pX/j/PwA).
[Answer]
# PHP, 89 bytes
```
do echo[Grey,Red,Orange,Yellow,Green,Blue,Indigo,Violet][$i=rand()%8]," Duck
";while($i);
```
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/d46be81de712f91a00fdaf2eb781d265af8bf13b).
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 107 bytes
```
x<>" duck"a>
x<^"deR"
x<^"egnarO"
x<^"wolleY"
x<^"neerG"
x<^"eulB"
x<^"ogidnI"
x<^"teloiV"
x"Grey duck"r>o|
```
[Try it online!](https://tio.run/##S8sszvj/v8LGTkkhpTQ5WynRjqvCJk4pJTVICcxITc9LLPKHsMvzc3JSIyHsvNTUIneoktIcJwgrPz0zJc8Twi5JzcnPDAOyldyLUishhhfZ5df8/w8A "><> – Try It Online")
[Answer]
# JavaScript, 104 bytes
```
f=_=>`grey,red,orange,yellow,green,blue,indigo,violet`.split`,`[n=Math.random()*8|0]+` duck
${n?f():``}`
```
[Try it online](https://tio.run/##DctBCsIwEADAu6/w4CHRtXgUofoCXyDixmYbY@NuSdJKUd8eex2YpxlNaqLv85bFUmmEkwSqgjilSlvf6iO6SBNEsiDRsCOYKAR5w8zEcA8DgWfrncDo55qxSn3wGQEvXJ9NflRzs/JSer3/7q4bXNqh6RarD59apQ@IPyxaaV3@)
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~114~~ 112 bytes
```
do disp([strsplit('Red Orange Yellow Green Blue Indigo Violet'){i=randi(7)},' duck'])until i>6
disp('Grey duck')
```
[Try it online!](https://tio.run/##JYy9CgIxDIB3nyJbWnDWSQcXcRIcBBGH4xKOYGiONvU4xGevh87fj/Xevbg1MiApY7gXz2VU8YAXJjjnLg0MN1a1CY6ZOcFBK8MpkQwGVzFlx/iW3WKShG38rBGo9k98xJpcFGS/Wf3euPTzn8XWvg "Octave – Try It Online")
There are a bunch of different options that are all between 112 and 118 bytes... Some initialize an index in the start and decrements it by a random number for each loop, and waits until it's **0**. Others use `printf` instead of `disp` to avoid some brackets and so on. 
[Answer]
# [PHP](http://php.net/), ~~133~~ ~~125~~ ~~111~~ ~~108~~ ~~97~~ 92 bytes
```
<?for(;$b=[Red,Orange,Yellow,Green,Blue,Indigo,Violet][rand(0,7)];)echo"$b duck
"?>Grey duck
```
[Try it online!](https://tio.run/##K8go@P/fxj4tv0jDWiXJNjooNUXHvygxLz1VJzI1Jye/XMe9KDU1T8cppzRVxzMvJTM9XycsMz8ntSQ2GqgsRcNAx1wz1lozNTkjX0klSSGlNDmbS8neDqirEsz5//9ffkFJZn5e8X/dFIXijPyikvj8gtS8@JLEdNv8PAA)
-8 bytes thanks to [@Olivier Grégoire](https://codegolf.stackexchange.com/users/16236/olivier-gr%C3%A9goire)
-3 bytes thanks to [@manatwork](https://codegolf.stackexchange.com/users/4198/manatwork)
-11 bytes thanks to [@Dom Hastings](https://codegolf.stackexchange.com/users/9365/dom-hastings)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~138~~ ~~133~~ ~~120~~ ~~117~~ 116 bytes
```
import os
while id:id=ord(os.urandom(1))%8;print"Grey Red Orange Yellow Green Blue Indigo Violet".split()[id],'duck'
```
[Try it online!](https://tio.run/##DcmxCsIwEADQ3a84CtIEpKCTKC4u4iQ4CCIO4h3t4TUXLgmlXx@7vhfnPGjY1cpjVMugaTUNLASMB8aTGjpNXbFPQB3d1vv1/hiNQ24uRjPcCeG2ZE/wJBGdYGEKcJZCcA3IvcKDVSg3XYrC2fkX43vTYvn@2lr/ "Python 2 – Try It Online")
Much better with some ideas from @EriktheOutgolfer. Thanks!
-3 more with thanks to @ovs
-1 with thanks to @Rod for a cool new trick learned :-)
[Answer]
# Python 3, 130, 128, 127, 126, 125 bytes
```
from random import*
d,c=1,'Grey Red Orange Yellow Green Blue Indigo Violet'.split()
while d!=c[0]:d=choice(c);print(d,'duck')
```
-1 by @ElPedro!  
-1 by me  
-1 by @Bubbler!
[Try it online!](https://repl.it/repls/WeakParallelDivisor)
[Answer]
## bash, 96 bytes
```
a=(Grey Red Orange Yellow Green Blue Indigo Violet);for((i=1;i;));{ echo ${a[i=RANDOM%8]} duck;}
```
Thanks to @DigitalTrauma.
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 114 bytes
```
{srand();for(split("Red9Orange9Yellow9Green9Blue9Indigo9Violet9Grey",A,9);r<8;print A[r]" duck")r=int(8*rand()+1)}
```
[Try it online!](https://tio.run/##SyzP/v@/urgoMS9FQ9M6Lb9Io7ggJ7NEQykoNcXSHyicnmoZmZqTk19u6V6Umppn6ZRTmmrpmZeSmZ5vGZaZn5NaApKoVNJx1LHUtC6ysbAuKMrMK1FwjC6KVVJIKU3OVtIssgWKaFhoQWzRNtSs/f@fCwA "AWK – Try It Online")
**Explanation**
```
{srand();                  # Seed rand to obtain different sequence each run
for(
     split("Red9Orange9Yellow9Green9Blue9Indigo9Violet9Grey",
            A,9);          # Split on 9 to avoid using '"'s
     r<8;
     print A[r]" duck")    # Print the colored ducks
     r=int(8*rand()+1)     # AWK uses 1-indexing not 0-indexing when splitting strings into arrays
}
```
Note that this requires "some" input. The input can be empty. To avoid the need for input prepend the first line with `BEGIN`
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 94 bytes
```
for(;$r-ne'Grey'){$r=-split"Red
Orange
Yellow
Green
Blue
Indigo
Violet
Grey"|Random;"$r Duck"}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Py2/SMNapUg3L1XdvSi1Ul2zWqXIVre4ICezRCkoNYXLvygxLz2VKxKoOL@cC6gkNY/LKac0lcszLyUzPZ8rLDM/J7UEJFGpVBOUmJeSn2utpFKk4FKanK1U@/8/AA "PowerShell – Try It Online")
Loops until `$r` is equal to `Grey`. Inside the loop, `-split`s the literal string on newlines, chooses a `Random` one thereof, then prints out the color plus `Duck` (technically, it's left on the pipeline and pipeline cleanup on the next loop iteration causes a `Write-Output` to happen). Note that it's theoretically possible for `Grey` to never be chosen, and the loop to continue infinitely, but this almost never (in the probability sense) will happen.
[Answer]
# [R](https://www.r-project.org/), 101 bytes
```
cat(paste(c(sample(scan(,""),rexp(1),T),"gray"),"duck\n"))
Red
Orange
Yellow
Green
Blue
Indigo
Violet
```
[Try it online!](https://tio.run/##DcixCgIxDADQPZ@RKYUu/oKL3CSICIJLaEM5jGlJe9z59dU3Pp8z8aDGfQgl6vxpKtQTG0XEEF2ORqcQ7yFicf7@C/OW3i/DEOAmGa7OVgSeolp3uLiIwVk3gcXyWio81qoy5vwB "R – Try It Online")
Heavily inspired by [@user2390246's answer](https://codegolf.stackexchange.com/a/157920/67312) to the related challenge. We need two sources of randomness: Changing the order of the colors and sampling the non-gray duck colors. The `sample` will take a random sample of random size given by an exponential distribution with rate parameter `1`, truncated to an integer. Using an exponential distrubtion unfortunately means that there is a probability of `exp(-8)` or around `0.0003354` that the sample will be at least `8`, so we have to sample with `replace=T`.
[Answer]
## [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~69~~ 68 bytes
*Thanks to Leo for saving 1 byte.*
```
.^/y/{K`Red¶Orange¶Yellow¶Green¶Blue¶Indigo¶Violet¶Grey
" duck¶">?G`
```
[Try it online!](https://tio.run/##K0otycxLNPz/Xy9Ov1K/2jshKDXl0Db/osS89NRD2yJTc3Lyyw9tcy9KTc07tM0ppxQo6JmXkpmef2hbWGZ@TmoJWLKSS0khpTQ5@9A2JTt794T//wE "Retina – Try It Online")
### Explanation
```
./y/^{K`Red¶Orange¶Yellow¶Green¶Blue¶Indigo¶Violet¶Grey
```
`.` suppresses implicit output at the end of the program (otherwise, we'd get two grey ducks). `/y/^{` wraps the entire program in a loop which continues as long as the working string doesn't contain a `y`. The rest of that line sets the working string to a linefeed-separated list of all the colours.
```
" duck¶">G?`
```
We grep a random line from the working string (and therefore a random colour). And we print the result with a trailing  `duck` and a linefeed.
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~68~~ 64 bytes
```
`'DYCIXMSQ(qm#Q$4{#is,Gh1(=lAjUSId;&'F2Y232hZaYb8YrX)' duck'h7Mq
```
[Try it online!](https://tio.run/##y00syfn/P0HdJdLZM8I3OFCjMFc5UMWkWjmzWMc9w1DDNscxKzTYM8VaTd3NKNLI2CgjKjEyySKyKEJTXSGlNDlbPcPct/D/fwA)
# Explanation
```
`                         % Do...while
  'DYCI···Id;&'           %   Push this string (to be decompressed by base conversion)
  F                       %   Push false
  2Y2                     %   Push string 'abc...xyz'
  32                      %   Push 32 (ASCII for space)
  h                       %   Concatenate horizontally. Gives 'abc...xyz '
  Za                      %   Base-convert from alphabet of all printable ASCII
                          %   characters except single quote (represented by input
                          %   false) to alphabet 'abc...xyz '. Produces the string
                          %   'grey red ··· violet'
  Yb                      %   Split on space. Gives a cell array of strings
  8Yr                     %   Random integer from 1 to 8, say k
  X)                      %   Get the content of the k-th cell
  ' duck'                 %   Push this string
  h                       %   Concatenate horizontally
  7M                      %   Push k again
  q                       %   Subtract 1
                          % Implicit end. Run a new iteration if top of the stack
                          % is non-zero
                          % Implicit display
```
[Answer]
# [Python 2](https://docs.python.org/2/), 98 bytes
**Look ma no imports!**
```
v=0
while 1:x=id(v)%97%8;print"GVIYORGBrinererleodladeuyliln ee egog n  towe"[x::8],"duck";v=1/x,v
```
(Prints extra spaces between the colours and `duck` as allowed in the question)
**[Try it online!](https://tio.run/##K6gsycjPM/r/v8zWgKs8IzMnVcHQqsI2M0WjTFPV0lzVwrqgKDOvRMk9zDPSP8jdCchJLUotyknNT8lJTEktrczJzMlTSE1VSE3PT1fIU1AoyS9PVYqusLKyiNVRSilNzlayLrM11K/QKfv/HwA "Python 2 – Try It Online")**
A pretty poor pseudo-random number generator seeded with the object id of **0** (but it seems to fit the spec) which repeatedly yields an integer, `x`, in **[0,7]** which is used to slice a list of characters from that index in steps of **8** to get the colour name which is printed along with `duck` as a tuple, forcing a space in-between. When `x` becomes zero `Grey` is printed and the evaluation of the next input to the modulo based random number generator errors attempting to divide by zero (`v=1/x,v` tries to make a new tuple with the first element `1/x` = `1/0`)
---
Same way is 100 in Python 3 with
```
v=0
while 1:x=id(v)%17%8;print("GVIYORGBrinererleodladeuyliln ee egog n  towe"[x::8],"duck");v=1/x,v
```
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 287 bytes
```
Random r=new Random();int i;String c;do{i=r.nextInt(8);switch(i){case 0:c="Red";break;case 1:c="Orange";break;case 2:c="Yellow";break;case 3:c="Green";break;case 4:c="Blue";break;case 5:c="Indigo";break;case 6:c="Violet";break;default:c="Gray";}System.out.println(c+" duck");}while(i!=7)
```
[Try it online!](https://tio.run/##Vc9NS8QwEAbgs/srxp5axOK3YujFi@xBhF0QZPGQTcbutGlSkunWpfS319bioafhfeYDppBHeVnocqCqdp6hGHPaMJl0I612lVgpI0OAN0kWutVZ3ewNKQgseSxHRxqqsRVv2ZPNd18gfR4S6IZ5HXxmsYU5xIkgy0BiHgYltOso86nFH15bjp8SEVpidYgp6ZQMCFfPKos2qCOx9yhL8YfXE757aXNc@M3kn2iMaxd@O/mrR7QLvpv4xTTLI/eTrq2m3C38YfIPcgb53zV@y8bwfF2eItFvT4GxSl3DaT2@yMbG6iIC3agySkTfHshgTOfZYzKIvh9@AQ "Java (JDK 10) – Try It Online")
My very first codegolf! Obviously not competitive, just happy to have learned enough Java (currently in CS200) to be able to participate. 
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 41 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
(’Red ṆỴ »Ẹ Ɓ# Ñɦ ƲỤ ṡʂ Ɓ~’OɼD‘ _*‘+£`Ɓ~Q
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faMGCpaUlaboWN101HjXMDEpNUXi4s-3h7i0Kh3Y_3LVD4VijssLhiSeXKRzb9HD3EqDcwlNNQME6oFr_k3tcHjXMUIjXApLahxYnAIUDlxQnJRdDjYQZDQA)
#### Explanation
```
(                     # While loop
 ’...’                # (condition)  Push compressed string of colours
      O               #              Split it on spaces
       ɼ              #              Pick a random item from this list
        D             #              Duplicate the item
         ‘ _*‘+       #              Append compressed string " duck"
               £      #              Pop and print with a newline
                `Ɓ~   #              Push compressed string "Grey"
                   Q  #              Check for inequality
                      # (body)  Do nothing
```
[Answer]
# [Kotlin](https://kotlinlang.org), 122 bytes
```
while({x:Any->println("$x duck");x!="Grey"}("Red,Orange,Yellow,Green,Blue,Indigo,Violet,Grey".split(",").shuffled()[0])){}
```
[Try it online!](https://tio.run/##HYu9CsIwFEb3PkUMDgnE4lxR0EWcBAVBxCHYmzb0elvS9I/SZ4/BD850zlfVHi0F0xH7akui1067gkXa7O6dpULOCYszQiZLkvQamdnPYSgtgpjH7EjT5tDE0CMJvh5Z3n0qLnfjas/PDia@CH6DXF2dpgLUExDrQUUDpE7YgbpQbotaPWyN4NX/krYNWi@44jJty84YhFzI1/Yt5byEJfwA "Kotlin – Try It Online")
[Answer]
# MS-SQL, 158 bytes
```
DECLARE @ VARCHAR(6)a:SELECT @=value FROM STRING_SPLIT('Red,Orange,Yellow,Green,Blue,Indigo,Violet,Grey',',')ORDER BY NEWID()PRINT @+' duck'IF @<>'Grey'GOTO a
```
Based largely on [Razvan's excellent answer](https://codegolf.stackexchange.com/a/159627/70172), but using the `STRING_SPLIT` function that is specific to MS-SQL 2016 and later. Also uses a `GOTO` instead of a `WHILE` loop.
Formatted:
```
DECLARE @ VARCHAR(6)
a:
    SELECT @=value FROM 
        STRING_SPLIT('Red,Orange,Yellow,Green,Blue,Indigo,Violet,Grey',',')
        ORDER BY NEWID()
    PRINT @+' duck'
IF @<>'Grey'GOTO a
```
]