¿Recuerdas el juego para niños, 'Pato, pato, ganso' ? ¿No? Yo tampoco.

El reto

• Imprima la palabra 'pato' en líneas individuales una cantidad indeterminada de veces.
• Imprime la palabra 'ganso'.
• Tu programa termina.

Las normas

• Intenta jugar el juego en la menor cantidad de bytes.
• Debe haber al menos un pato.
• Debe haber exactamente un ganso al final de la lista.
• Debe haber exactamente un pájaro en cada línea. No hay líneas vacías.
• El caso de las cadenas de salida es irrelevante.
• El espacio en blanco dentro de una línea está bien.
• Tu programa debe terminar.
• Su programa no debe producir constantemente la misma cantidad de patos.

¡Que te diviertas!

Tenga en cuenta: esta pregunta no es un duplicado del código más corto para producir una salida no determinista

Las razones incluyen:

• La asociación al juego de los niños.
• Los requisitos de inicio y finalización definidos de la cadena de resultados. No hay salida especificada en el otro desafío.
• Respuestas Para el otro, el desafío no duplicado está en un número de bytes de un solo dígito. El promedio para este es de alrededor de 30, o alrededor.
• Por la cantidad de superposición entre este desafío y aquel, cualquier pregunta de código de golf que incluya la etiqueta 'aleatoria' es un duplicado. ¿Deberíamos eliminarlos a todos?
• Las respuestas del código para este desafío coincidirían con el otro desafío (de una manera ridículamente hinchada), pero las respuestas a ese desafío no coincidirían con este.

Jalea , 13 bytes

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

Pruébalo en línea!

Explicación:

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

Versión más legible: ¡ Pruébelo en línea!

Siempre devolverá 1 o 2 patos.

Lenguaje de script Operation Flashpoint , 48 bytes

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

Siempre imprime uno o dos patos.

random 1devuelve un número (punto flotante) entre 0 y 1. Ese número se pasa como argumento selectjunto con la matriz [s,""]. El número aleatorio se redondea al entero más cercano (0 o 1), y el elemento de matriz en ese índice se selecciona de la matriz.

Llamar con:

hint call f

Salida:

Versión alternativa de 56 bytes:

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

World of Warcraft 81 Bytes

Aquí hay una macro que puedes ejecutar en World of Warcraft.

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

Minecraft <1.13, 72 54 bytes

Lo siento, tuve que hacerlo.

Instrucciones:

• Crea un nuevo mundo de Minecraft en modo creativo
• Busque la carpeta de guardar para ese mundo y coloque el siguiente código en data/functions/minecraft/ddg.mcfunction
• Ejecutar /function ddgen la consola de juegos

Cómo funciona:

Emite la palabra "pato" para cada entidad en el mundo, luego emite la palabra "ganso". Dado que las entidades están constantemente engendrando y desapareciendo, el número de "pato" no será consistente. Utilicé en tellrawlugar del mucho más corto sayporque saygenera el nombre de la entidad, mientras que tellrawgenera exactamente lo que se le dice.

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

Captura de pantalla

Editar: se cambió {"text": "duck"} a solo "duck" (y lo mismo con "goose")

JavaScript, 45 44 42 39 37 bytes

Tiene el potencial de producir un error de desbordamiento.

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

Pruébalo

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

<pre id=o></pre>

Octava , 38 33 bytes

Este no es el más corto (son 36 bytes), pero es mi favorito. La explicación está en la parte inferior.

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

Pruébalo en línea!

Algunas variaciones más cortas:

Esto funciona en principio (33 bytes), pero los intérpretes en línea agota el tiempo de espera:

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

Agregar algunos bytes para acortar la salida hace que sea 35 o 36 bytes:

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

Explicación:

Solo explicaré el último al azar. Los otros son similares, pero usan la cantidad de días desde el 1 de enero de 0000 hasta hoy.

randdevuelve un número aleatorio en el intervalo (0, 1) . Por lo tanto, 1/randdevuelve un número mayor que 1 . Dado que un rango 1:f, donde fes un flotante aleatorio mayor que 1, es idéntico a 1:floor(f), 1:1/randcrea un rango 1 .. x , donde x> = 1 .

Trataré de explicar esto como si Octave fuera un lenguaje basado en la pila.

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

Perl 5 , 20 bytes

Primero un práctico 26 bytes:

Patos 1 a 9 veces antes de ser engullido.

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

Pruébalo en línea!

Pero si tiene mucha memoria y tiempo, esta versión de 20 bytes (como lo sugiere Chris ) también funciona:

say"Duck
"x$^T,Goose

Esto también supone que el problema del año 2038 se resolverá para Perl 5 , de lo contrario será inválido durante 1 segundo dentro de 20 años.

Python 2 , 36 34 bytes

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

¡Pruébelo en línea!

La sugerencia de Kevin Cruijssen nos lleva a 34 bytes:

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

Z Shell (+ wget y 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)

No es la solución más corta, pero tuve ganas de darle un giro a este desafío (inspirado en la solución de @ AlexG a este otro problema ).

Este script genera una imagen PPM que contiene entre 1 y 8 imágenes de patos y una imagen de un ganso en la parte inferior en la salida estándar. Descarga las dos imágenes fuente de Wikipedia, por lo que el acceso a Internet es necesario para que funcione.

Salida de muestra convertida a JPEG a través de pnmtojpeg :

R , 35 bytes

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

Pruébalo en línea!

rexp()produce un número aleatorio a partir de una función de disminución exponencial. +1para asegurar al menos un pato. Todas las líneas después de la primera incluyen un espacio inicial (que es el separador predeterminado cat), pero esto está permitido.

Bash , 39 38 37 bytes

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

Pruébalo en línea!

Imprime un número de patos igual al número de dígitos en un número entero distribuido uniformemente en [0,32767] (por lo tanto, la mayoría de las veces, cinco patos (un buen número de patos)).

-1 byte cada uno gracias a @Chris y @sch señalando pares de citas que no estaban presionando su peso.

Pure Bash (sin utilidades externas), 25

Basado en la respuesta de @ SophiaLechner , esto también imprime una buena cantidad de patos .

La idea de @ OlivierDulac de usar el script PID shell almacenado en el $parámetro ahorra 5 bytes.

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

Pruébalo en línea .

Rubí , 30 bytes.

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

Pruébalo en línea!

Nota: realmente 31 bytes sin el \ntruco.

Bash + Coreutils, 36 27 bytes

yes duck|sed $$q;echo goose

Imprime demasiados patos (entre 2 y cat /proc/sys/kernel/pid_max), luego un ganso.

Ahorró nueve bytes gracias a Digital Trauma y Olivier Dulac.

Pruébalo en línea! (pero tenga en cuenta que puede truncarse ocasionalmente)

Misma longitud, pero sin echo:

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

Pruébalo en línea!

aes el comando anexar sedy se qcierra. Ambos solo se ejecutan en la línea $$, que corresponde al PID.

PowerShell , 35 30 28 bytes

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

Pruébalo en línea! (versión modificada)

Genera una matriz de Get-Randomnúmero de artículos. Podría tomar un tiempo. Esto agrega una +1para garantizar que obtengamos al menos uno duck. La versión modificada también incluye un -maindicador ximum 5para que pueda ver que el programa funciona como se esperaba (la versión modificada se imprimirá 1, 2, 3 o 4 ducks antes de goose).

La matriz y la goosecadena solitaria se dejan en la tubería, y lo implícito Write-Outputnos da valores separados por la nueva línea de forma gratuita.

No sabes lo difícil que fue para mí no cambiar la última línea a "pato gris" ...

Python 2 , 54 bytes

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

¡Pruébelo en línea!

C # (compilador interactivo de Visual C #) , 55 bytes

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

Pruébalo en línea!

Brachylog , 24 21 bytes

-3 bytes gracias a Erik the Outgolfer

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

Pruébalo en línea!

En celebración del Idioma del mes , mi primera publicación de brachylog El flujo de control en este idioma es genial.

Cómo funciona:

"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

Geometry Dash World 2.2 Editor - 4 objetos

Explicación:

El disparador BG es el disparador aleatorio actual de 2.2, por lo que alterna el ID de grupo 1 o 2.

El primer "PATO" tiene una identificación de grupo de 1, lo que hace que tenga un 50% de posibilidades de ser eliminado o no (activado).

No hay ningún objeto con el ID de grupo 2 en este nivel, por lo que hay un 50% de posibilidades de que se muestren 2 "PATO".

Cómo reproducir esto:

El primer "PATO" tiene una ID de grupo de 1.

Goose y 2nd duck no tienen ID de grupo

Dentro del disparador aleatorio.

05AB1E , 15 14 bytes

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

Pruébalo en línea!

Imprimirá 2, 5 o 6 patos y luego ganso.

-1 byte gracias a @Emigna usando 'para una sola palabra comprimida (pato)

APL (Dyalog) , 22 bytes

1 byte guardado gracias a @EriktheOutgolfer

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

Pruébalo en línea!

Retina , 17 bytes

?\\K`duck
K`goose

Pruébalo en línea!

Pruébalo en línea!

Imprime 1 o 2 patos, con la misma probabilidad.

Explicación

?\\K`duck

Establezca la cadena de trabajo ducke imprímala con un salto de línea final ( \). Luego, esto se envuelve en otra etapa de salida, pero esta tiene ?aplicada la bandera aleatoria ( ), por lo que solo se imprime con una probabilidad del 50%.

K`goose

Reemplace duckcon goose, que se imprime implícitamente al final del programa.

Aquí hay una alternativa divertida que imprime 1 pato con 50% de probabilidad, 2 patos con 25%, 3 patos con 12.5% ​​...:

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

Vim (script) en Linux, 46 43 bytes (4946 con :al inicio de la línea)

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

Ejecutado como vim -S filenameo pegado en ejecución vimcon :antes de cada línea.

> <> , 31 22 bytes

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

Pruébalo en línea!

-9 bytes basados ​​en la revisión de No es un árbol

Befunge 98 , 38 30 25 bytes

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

Pruébalo en línea!

• Gracias @JoKing por desnudar el trampolín inútil.
• Cambiar a Befunge 98 para una nueva línea más corta: ahora Duckcabe en una sola cadena

T-SQL , 70 44 43 bytes (Muchos patos)

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

Gracias @Zac Faragher!

Versión revisada, 54 43 40 bytes (1 o 2 patos)

Gracias @BradC!

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

Parece que no puedo hacer que esto se ejecute correctamente en SQL Fiddle , pero funciona bien en LINQPad y SSMS.

No estoy seguro de si esta es una limitación conocida de SQL Fiddle o simplemente estoy haciendo algo mal

Powershell - 31 30 bytes

Advertencia : lo más probable es que termines con muchos patos. Randomincluye los valores de 0, por Int32.MaxValuelo que, dependiendo de cuán aleatorio sea su número, esto podría ser una gran cantidad de graznidos.

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

Fisión , 24 19 bytes

R"duck"N#
"goose"*[

Pruébalo en línea!

-5 bytes gracias a Martin Ender

Brachylog , 21 bytes

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

Pruébalo en línea!

Oye, el idioma del mes está inactivo, ¡vamos a mejorar un poco las cosas!

Befunge

57 35 bytes (el perímetro de todo el campo es de 19x3 17x2 caracteres) Gracias a Karhell por la mejora.

55+"kcud",,,,,#v?
  @,,,,,"goose"<

La segunda línea pone pato y una nueva línea en la pila (al revés) y la genera como una cadena. Después de ese 75% de posibilidades de volver al inicio e imprimir pato nuevamente, 25% (cuando el signo de interrogación decida bajar) para imprimir ganso y detenerse.