Tu te souviens du jeu pour enfants 'Canard, Canard, Oie' ? Non? Moi non plus.

Le défi

• Imprimez le mot 'canard' sur chaque ligne un nombre de fois indéterminé.
• Imprimez le mot 'oie'.
• Votre programme se termine.

Les règles

• Essayez de jouer le jeu dans le moins d'octets.
• Il doit y avoir au moins un canard.
• Il doit y avoir exactement une oie à la fin de la liste.
• Il doit y avoir exactement un oiseau sur chaque ligne. Pas de lignes vides.
• Le cas des chaînes sorties n'est pas pertinent.
• Les espaces dans une ligne sont acceptables.
• Votre programme doit finir.
• Votre programme ne doit pas produire systématiquement le même nombre de canards.

S'amuser!

Remarque: cette question n'est pas une copie du code le plus court pour produire une sortie non déterministe.

Les raisons incluent:

• L'association au jeu d'enfants
• Les exigences de début et de fin définies pour la chaîne de résultat. Il n'y a pas de sortie spécifiée dans l'autre défi.
• Réponses Pour l'autre défi, le non-doublon est composé d'un nombre d'octets à un chiffre. La moyenne pour celui-ci est d'environ 30, ou environ.
• Du fait du chevauchement entre ce défi et celui-là, toute question de code-golf incluant la balise 'random' est un doublon. Devrions-nous les supprimer tous?
• Les réponses de code pour ce défi correspondraient à l'autre défi (d'une manière ridiculement démesurée), mais les réponses à ce défi ne correspondraient pas à celui-ci.

Gelée , 13 octets

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

Essayez-le en ligne!

Explication:

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

Version plus lisible: Essayez-le en ligne!

Reviendra toujours 1 ou 2 canards.

Langage de script Operation Flashpoint , 48 octets

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

Imprime toujours un ou deux canards.

random 1renvoie un nombre (à virgule flottante) compris entre 0 et 1. Ce nombre est passé en tant qu'argument selectavec le tableau [s,""]. Le nombre aléatoire est ensuite arrondi au nombre entier le plus proche (0 ou 1) et l'élément de tableau à cet index est sélectionné dans le tableau.

Appeler avec:

hint call f

Sortie:

Version alternative de 56 octets:

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

World of Warcraft 81 octets

Voici une macro que vous pouvez exécuter dans World of Warcraft.

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

Minecraft <1.13, 72 54 octets

Désolé, je devais.

Instructions:

• Créer un nouveau monde Minecraft en mode créatif
• Recherchez le dossier de sauvegarde de ce monde et placez le code suivant dans data/functions/minecraft/ddg.mcfunction
• Courir /function ddgdans la console de jeu

Comment ça fonctionne:

Affiche le mot "canard" pour chaque entité du monde, puis le mot "oie". Étant donné que les entités sont constamment en train de se reproduire et de disparaître, le nombre de "canards" ne sera pas constant. J'ai utilisé tellrawau lieu de beaucoup plus court sayparce que saysort le nom de l'entité, alors que tellrawsort exactement ce qui est dit.

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

Capture d'écran

Éditer: {"text": "canard"} remplacé par "canard" (et la même chose avec "oie")

JavaScript, 45 44 42 39 37 octets

A le potentiel de produire une erreur de débordement.

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

Essaye-le

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

<pre id=o></pre>

Octave , 38 33 octets

Ce n'est pas le plus court (c'est 36 octets), mais c'est mon préféré. L'explication est en bas.

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

Essayez-le en ligne!

Quelques variations plus courtes:

Cela fonctionne en principe (33 octets), mais les interprètes en ligne expirent:

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

L'ajout d'octets pour raccourcir la sortie en fait 35 ou 36 octets:

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

Explication:

Je vais juste expliquer le dernier aléatoire. Les autres sont similaires, mais utilisent le nombre de jours depuis le 1er janvier 0000 à aujourd'hui.

randrenvoie un nombre aléatoire sur l'intervalle (0, 1) . Ainsi, 1/randrenvoie un nombre supérieur à 1 . Dans la mesure 1:foù une plage , où fun flottant aléatoire supérieur à 1 est identique à 1:floor(f), 1:1/randcrée une plage 1 .. x , où x> = 1 .

Je vais essayer d'expliquer cela comme si Octave était un langage basé sur la pile.

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

D'abord un 26 octets pratique:

Canards 1 à 9 fois avant d'être oie.

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

Essayez-le en ligne!

Mais si vous avez beaucoup de mémoire et de temps, cette version de 20 octets (suggérée par Chris ) fonctionne également:

say"Duck
"x$^T,Goose

Cela suppose également que le problème de l' an 2038 sera résolu pour Perl 5 , sinon il ne sera plus valable dans 1 seconde d'ici 20 ans.

Python 2 , 36 34 octets

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

Essayez-le en ligne!

La suggestion de Kevin Cruijssen nous amène à 34 octets:

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

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

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

Ce n’était pas la solution la plus courte, mais j’avais envie de donner une tournure à ce défi (inspiré par la solution de @ AlexG à cet autre problème ).

Ce script génère une image PPM contenant entre 1 et 8 images de canards et une image d’une oie au bas de la sortie standard. Il télécharge les deux images sources de Wikipedia, un accès Internet est donc nécessaire pour que cela fonctionne.

Exemple de sortie convertie au format JPEG via pnmtojpeg :

R , 35 octets

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

Essayez-le en ligne!

rexp()produit un nombre aléatoire à partir d'une fonction de décroissance exponentielle. +1assurer au moins un canard. Toutes les lignes après la première incluent un espace de début (qui est le séparateur par défaut cat), mais cela est autorisé.

Bash , 39 38 37 octets

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

Essayez-le en ligne!

Imprime un nombre de canards égal au nombre de chiffres d'un nombre entier uniformément distribué sur [0,32767] (donc, le plus souvent, cinq canards (un bon nombre de canards)).

-1 octet chaque grâce à @Chris et @sch en soulignant des paires de citations qui ne tiraient pas leur poids.

Pure Bash (aucun utilitaire externe), 25

D' après la réponse de @ SophiaLechner , cela permet également d'imprimer un bon nombre de canards .

L'idée de @ OlivierDulac d'utiliser le PID du shell de script tel que stocké dans le $paramètre enregistre 5 octets.

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

Essayez-le en ligne .

Ruby , 30 octets

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

Essayez-le en ligne!

Note: vraiment 31 octets sans \ntriche.

Bash + Coreutils, 36 27 octets

yes duck|sed $$q;echo goose

Imprime trop de canards (entre 2 et cat /proc/sys/kernel/pid_max), puis une oie.

Sauvé neuf octets grâce à Digital Trauma et Olivier Dulac.

Essayez-le en ligne! (mais gardez à l'esprit qu'il peut parfois être tronqué)

Même longueur, mais sans echo:

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

Essayez-le en ligne!

aest la commande append dans sedet qquitte. Les deux ne fonctionnent que sur la ligne $$, ce qui correspond au PID.

PowerShell , 35 30 28 octets

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

Essayez-le en ligne! (version modifiée)

Génère un tableau de Get-Randomnombre d'éléments. Ça peut prendre un moment. Cela ajoute un +1pour s'assurer que nous en obtenons au moins un duck. La version modifiée inclut également un -maindicateur ximum de 5sorte que vous puissiez voir que le programme fonctionne comme prévu (la version modifiée imprimera 1, 2, 3 ou 4 ducks avant le goose).

Le tableau et la goosechaîne solitaire sont laissés sur le pipeline et l'implicite Write-Outputnous donne gratuitement des valeurs séparées par une nouvelle ligne.

Vous ne savez pas combien il a été difficile pour moi de ne pas changer la dernière ligne en "canard gris" ...

Python 2 , 54 octets

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

Essayez-le en ligne!

C # (compilateur interactif Visual C #) , 55 octets

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

Essayez-le en ligne!

Brachylog , 24 21 octets

-3 octets grâce à Erik l'Outgolfer

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

Essayez-le en ligne!

En célébration de la langue du mois , mon premier post de brachylog. Le flux de contrôle dans cette langue est cool.

Comment ça fonctionne:

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

Explication:

Le déclencheur BG est le déclencheur aléatoire de la version 2.2 actuelle. Il permet donc d'activer ou de désactiver l'ID de groupe 1 ou 2.

Le premier "DUCK" a un identifiant de groupe de 1, ce qui lui donne 50% de chances d’être supprimé ou non (basculé).

Il n'y a pas d'objet avec l'ID de groupe 2 dans ce niveau, donc il y a 50% de chances que 2 "DUCK" soient affichés.

Comment reproduire ceci:

Le premier "DUCK" a un identifiant de groupe de 1.

Oie et 2nd canard n'ont pas d'identifiant de groupe

À l'intérieur du déclencheur aléatoire.

05AB1E , 15 14 octets

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

Essayez-le en ligne!

Imprimera 2, 5 ou 6 canards, puis l'oie.

-1 octet grâce à @Emigna qui utilise 'pour un seul mot compressé (canard)

APL (Dyalog) , 22 octets

1 octet enregistré grâce à @EriktheOutgolfer

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

Essayez-le en ligne!

Retina , 17 octets

?\\K`duck
K`goose

Essayez-le en ligne!

Essayez-le en ligne!

Imprime 1 ou 2 canards, avec une probabilité égale.

Explication

?\\K`duck

Définissez la chaîne de travail sur ducket imprimez-la avec un saut de ligne de fin ( \). Ensuite, ceci est encapsulé dans une autre étape de sortie, mais le drapeau aléatoire ( ?) lui est appliqué. Il est donc imprimé avec une probabilité de 50%.

K`goose

Remplacez le duckavec goose, qui est imprimé implicitement à la fin du programme.

Voici une alternative amusante qui imprime 1 canard avec une probabilité de 50%, 2 canards avec 25%, 3 canards avec 12,5% ...:

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

Vim (script) sur Linux, 46 43 octets (4946 avec :en début de ligne)

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

Exécuté en tant que vim -S filenameou collé dans l'exécution vimavec :avant chaque ligne.

> <> , 31 22 octets

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

Essayez-le en ligne!

-9 octets basés sur la révision d'une arborescence

Befunge 98 , 38 30 25 octets

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

Essayez-le en ligne!

• Merci @JoKing d'avoir enlevé le trampoline inutile
• Passage à Befunge 98 pour une nouvelle ligne plus courte - Ducks'adapte désormais à une seule chaîne

T-SQL , 70 44 43 octets (plusieurs canards)

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

Merci @Zac Faragher!

Version révisée, 54 43 40 octets (1 ou 2 canards)

Merci @ BradC!

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

Je n'arrive pas à obtenir que cela fonctionne correctement dans SQL Fiddle , mais cela fonctionne parfaitement dans LINQPad et SSMS.

Je ne sais pas s'il s'agit d'une limitation connue de SQL Fiddle ou si je fais quelque chose de mal

Powershell - 31 à 30 octets

Attention : vous allez probablement vous retrouver avec beaucoup de canards. Randominclut les valeurs de 0 à Int32.MaxValue50%, ce qui peut donner beaucoup de fracas, selon le nombre de vos personnages.

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

Fission , 24 19 octets

R"duck"N#
"goose"*[

Essayez-le en ligne!

-5 octets grâce à Martin Ender

Brachylog , 21 octets

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

Essayez-le en ligne!

Hé, la langue du mois qui devient inactive, passons un peu aux choses!

Befunge

57 35 octets (le périmètre de tout le champ est de 19x3 caractères 17x2) Merci à Karhell pour l’amélioration.

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

La deuxième ligne place canard et une nouvelle ligne sur la pile (en arrière) et le sort sous forme de chaîne. Après 75% de chances de revenir au début et d’imprimer à nouveau le canard, 25% (lorsque le point d’interrogation décide de descendre) d’imprimer de l’oie et de s’arrêter.