Blue duck, red duck, gray duck

Question

So, last week I posted a challenge to play Duck, Duck, Goose. This lead to a number of Minnesotans commenting about their regional 'Gray duck' variation.

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 1

T-SQL, 195 185 184 bytes

DECLARE @ VARCHAR(9)=''WHILE @<>'Grey'BEGIN SELECT @=c FROM(VALUES('Red'),('Orange'),('Yellow'),('Green'),('Blue'),('Indigo'),('Violet'),('Grey'))v(c)ORDER BY NEWID()PRINT @+' Duck'END

Answer 2

x86_64 machine code, 120 bytes.

I got inspired by the 6502 machine code and implemented the same in x86_64 machine code.

0x603000: 0x47    0x72    0x61    0x79    0x20    0x00    0x00    0x00
0x603008: 0x52    0x65    0x64    0x20    0x00    0x00    0x00    0x00
0x603010: 0x4f    0x72    0x61    0x6e    0x67    0x65    0x20    0x00
0x603018: 0x59    0x65    0x6c    0x6c    0x6f    0x77    0x20    0x00
0x603020: 0x47    0x72    0x65    0x65    0x6e    0x20    0x00    0x00
0x603028: 0x42    0x6c    0x75    0x65    0x20    0x00    0x00    0x00
0x603030: 0x49    0x6e    0x64    0x69    0x67    0x6f    0x20    0x00
0x603038: 0x56    0x69    0x6f    0x6c    0x65    0x74    0x20    0x00
0x603040: 0x64    0x75    0x63    0x6b    0x0a    0x00    0x0f    0x31
0x603048: 0xc1    0xe8    0x03    0x33    0xdb    0x83    0xc3    0x07
0x603050: 0x23    0xd8    0x8b    0xfb    0xc1    0xe7    0x03    0x48
0x603058: 0x81    0xc7    0x00    0x30    0x60    0x00    0xe8    0x73
0x603060: 0xd5    0xdf    0xff    0x48    0xc7    0xc7    0x40    0x30
0x603068: 0x60    0x00    0xe8    0x67    0xd5    0xdf    0xff    0x85
0x603070: 0xdb    0x0f    0x85    0xcf    0xff    0xff    0xff    0xc3

Or the disassembly:

   0x603046:  rdtsc  
   0x603048:  shr    eax,0x3
   0x60304b:  xor    ebx,ebx
   0x60304d:  add    ebx,0x7
   0x603050:  and    ebx,eax
   0x603052:  mov    edi,ebx
   0x603054:  shl    edi,0x3
   0x603057:  add    rdi,0x603000
   0x60305e:  call   0x4005d6 <printf>
   0x603063:  mov    rdi,0x603040
   0x60306a:  call   0x4005d6 <printf>
   0x60306f:  test   ebx,ebx
   0x603071:  jne    0x603046
   0x603077:  ret     

The first 70 bytes is a string table that looks like:

Gray\0\0\0\0
Red\0\0\0\0\0
Yellow\0\0
...
 duck\0

There is certainly room for optimizations and it might not be the shortest implementation in terms of bytes but it probably competes for least amount of bytes executed :)

Answer 3

Japt, 54 53 52 bytes

Could probably be shorter but my tool for finding the optimal permutation of the string to compress is crapping out on this, for some reason.

_èSiy}a@P±` Ýõ
`i`gÎ9h½uehéHÃÎÁe⸩ºÄgohgyËB`qh ö

Test it

1 byte saved thanks to Oliver

Answer 4

APL (Dyalog Unicode), 86 bytes

{×⍵:∇r⊣⎕←'Grey' 'Red' 'Orange' 'Yellow' 'Green' 'Blue' 'Indigo' 'Violet'[r←?8]'duck'}1

Try it online!

Assumes ⎕IO←0.

Answer 5

Vyxal, 49 bytes

λ`⟇∴ ɾ⟩ °√ ×ŀ ⟇↵ ¯Ǔ⋏ġ Vio⟇» ←√`⌈℅:` ¦ø`+,‛←√≠[x|¤

Try it Online!

Answer 6

Red, 96 91 bytes

until[n: random 8 print[pick[Red Orange Yellow Green Blue Indigo Violet Grey]n"duck"]n = 8]

Try it online!

Answer 7

APL+WIN, 106 bytes

⊃('red' 'orange' 'yellow' 'green' 'blue' 'indigo' 'violet' 'grey')[(↑(m=8)/⍳⍴m)↑m←1+8|n←1E3?1E3],¨⊂' duck'

Generates a vector of random integers between 1 and 8 and takes the series up to and including the first occurance of an 8 as indices into the colour vector and then concatenates the duck.

Answer 8

SOGL V0.12, 40 39 38 bytes

]"sω2a⁄Ξ┌┼0⁾    a║EΣ?GΘƨ+}‘θJ;7ψ:≥w⁽OX@oo

Try it Here!

Answer 9

Pyth, 72 bytes^(SBCS)

K" Duck"#=kOc." y9Fª¹Ú¹«·.Û»õx¾jL[`ýõ?;ß¼<|9ü"\ +kKIqk"Gray"B

Try it online!

Python 3 translation:

import random
K=" Duck"
while True:
    k=random.choice("Red Orange Yellow Green Blue Indigo Violet Gray".split())
    print(k+K)
    if k=="Gray":
        break

Answer 10

Perl 6/Rakudo 78 bytes

say $_=<Grey Red Orange Yellow Green Blue Indigo Violet>.roll~" duck"until /y/

Stealing directly from Dom Hastings' Perl 5 answer

Perl 6 wins slightly with .roll

Answer 11

PHP, 166, 148, 142 98 Bytes

Down to 98 bytes thanks to Shaggy and Titus.

I tried a recursive solution.

function f(){echo[grey,red,orange,yellow,green,blue,indigo,violet][$n=rand()&7]." duck 
 ";$n&&f();}

Explanation

function f(){
  echo[grey,red,orange,yellow,green,blue,indigo,violet][$n=rand()&7]
  //a line break goes here, thats why it skips a line after duck
  //saves one byte over \n
        ." duck
         ";
  $n&&f();
}

For real it does not need much, the function will stop when $n == false or as php asumes $n == 0 as a false then it leaves the method.

Try it online

Don't really know how to "golf code", but i found this forum really, really fascinating.

Answer 12

Python 3, 127 bytes

from random import *;x=''
while'Grey'!=x:x=choice('Red,Orange,Yellow,Green,Blue,Indigo,Violet,Grey'.split(','));print(x,'duck')

Try it online!

Answer 13

Python 3, 124 bytes

import random
b=1
while b>0:b=random.randint(0,7);print('Gray Red Orange Yellow Green Blue Indigo Violet'.split()[b],'duck')

Try it online!

I almost always accompany my posts with explanations, but this one seems simple enough that I feel confident going without one...

Answer 14

SmileBASIC, 134 116 bytes

DIM C$[8]C=RND(8)COPY C$,@L@L?C$[C];" duck
EXEC!C
DATA"Gray","Red","Orange","Yellow","Green","Blue","Indigo","Violet

Answer 15

T-SQL, 211 178 bytes

SELECT c+' Duck'FROM(SELECT TOP(CAST(RAND()*9AS INT))c FROM(VALUES('Red'),('Orange'),('Yellow'),('Green'),('Blue'),('Indigo'),('Violet'))v(c)ORDER BY NEWID()UNION SELECT'Grey'c)q

SQLFiddle

Answer 16

Swift, 161 143 bytes

import Foundation;var x=9;while x>0{x=time(nil)%7;print(["Grey","Red","Orange","Yellow","Green","Blue","Indigo","Violet"][x]+" duck");sleep(1)}

Thanks to @cleblanc, whom I got the idea of the shorter code from.

Explanation

import Foundation                   //we need Foundation for time

var x = 9

while x > 0 {
    x = time(nil)%7
    print(["Grey",
           "Red",
           "Orange",
           "Yellow",
           "Green",
           "Blue",
           "Indigo",
           "Violet"][x] + " duck") //subscripting color array, appending "duck"
            sleep(1)
}

Try it online!

Answer 17

F#, 171 bytes

let r=System.Random()
let mutable i=r.Next(8)
while i<>7 do
 printfn"%s duck"["Red";"Orange";"Yellow";"Green";"Blue";"Indigo";"Violet"].[i]
 i<-r.Next(8)
printf"Grey duck"

Try it online!

That flipping "mutable" keyword! I thought that F#'s lack of a do/while loop (it only has while/do) would hurt me, but on retrospect it worked out, since "Grey duck" is always printed without a line separator (printfn versus printf), so there's no trailing empty line.

Answer 18

C (gcc), 104 bytes

f(n){for(;printf("%.6s duck\n","Gray\0 OrangeYellowIndigoVioletGreen\0Blue\0 Red"+(n=time(0)%7)*6),n;);}

Try it online!

Answer 19

Visual Basic for Applications, 110 102 bytes

Edit: saved eight more bytes by using split() instead of array()

while rnd>.3:?split("Red,Orange,Yellow,Green,Blue,Indigo,Violet",",")(rnd*6)+" duck":wend:?"Gray duck"

Type in the immediate window.

Answer 20

TI-BASIC, 80 bytes

Repeat not(I
int(8rand→I
Disp sub("GRAY  RED   ORANGEYELLOWGREEN BLUE  INDIGOVIOLET",6I+1,6)+" DUCK
End

Answer 21

Bash + Coreutils, 100 Bytes

B=`shuf -en1 Red Orange Yellow Green Blue Indigo Violet Gray`;echo $B duck;[[ $B = Gray ]]||bash $0

Answer 22

C (gcc), 138 133 123 122 bytes

Saved a byte thanks to @ceilingcat

*c[]={"Grey","Red","Orange","Yellow","Green","Blue","Violet"};main(i){for(;printf("%s duck\n",c[i=time(sleep(1))%6])*i;);}

Try it online!

Answer 23

ink, 78 87 bytes

-(e){RANDOM(0,1):{~Red|Orange|Yellow|Green|Blue|Indigo|Violet} duck|Gray duck->END}
->e

Try it online!

Explanation

-(e){RANDOM(0,1):{~Red|Orange|Yellow|Green|Blue|Indigo|Violet} duck|Gray duck->END}  // With a 50% chance of each, either pick a colour that hasn't been picked already (unless all others have also been picked) and print it followed by "duck", or print "Gray duck" and terminate.
->e   // if we haven't terminated we get here and go back to the line above

+9 bytes: Apparently shuffles in ink will not repeat an option until all options have been visited. This means the previous version of my program was not valid, since it would always encounter "gray" before it could encounter any other colour for the second time, and thus broke the "Colours can be repeated" rule. The new answer will print each non-gray colour once until all have been printed, then shuffle again and restart - except every time it's about to pick a colour there's a 50% chance it instead prints gray and terminates.