Anatra, anatra, oca!

58

Ricordi il gioco per bambini "Anatra, Anatra, Oca" ? No? Neanche io.

La sfida

  • Stampa la parola 'anatra' su singole righe per un numero indeterminato di volte.
  • Stampa la parola "oca".
  • Il tuo programma termina.

Le regole

  • Tenta di giocare il minor numero di byte.
  • Deve esserci almeno un'anatra.
  • Ci deve essere esattamente un'oca, alla fine dell'elenco.
  • Ci deve essere esattamente un uccello su ogni linea. Nessuna riga vuota.
  • Il caso delle stringhe emesse è irrilevante.
  • Lo spazio bianco all'interno di una linea va bene.
  • Il tuo programma deve terminare.
  • Il tuo programma non deve produrre costantemente lo stesso numero di anatre.

Divertiti!

Nota: questa domanda non è un duplicato del codice più breve per produrre un output non deterministico

I motivi includono:

  • L'associazione a un gioco per bambini
  • I requisiti di inizio e fine definiti della stringa di risultati. Non vi è alcun output specificato nell'altra sfida.
  • Risposte Per l'altro, la sfida non duplicata è rappresentata da un numero di byte a una cifra. La media per questo è di circa 30 o circa.
  • Dalla quantità di sovrapposizione tra questa sfida e quella, qualsiasi domanda di code-golf incluso il tag 'random' è un duplicato. Dovremmo eliminarli tutti?
  • Le risposte del codice per questa sfida corrisponderebbero all'altra sfida (in modo ridicolmente gonfio), ma le risposte a quella sfida non corrisponderebbero a questa sfida.
code-golf  random 
— AJFaraday
fonte
11
Potresti definire indeterminato? Potrebbe significare zero o uno?
— ricorsivo
1
Si prega di definire la modalità di generazione casuale. Uniforme nella gamma o con declino esponenziale?
— HyperNeutrino,
@recursive No, ma andiamo con una definizione funzionante ... Il programma non presenta costantemente lo stesso numero di anatre.
— AJFaraday,
2
Parlando come un Minnesotan, cosa succede se la mia stampa invece "anatra, anatra, anatra grigia" ? :)
— Mike Hill
1
@ jpmc26 Sono sicuro che ce ne sono altri. Avresti dovuto giocarci con gli altri, per cominciare.
— AJFaraday,

Risposte:

9

Gelatina , 13 byte

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

Provalo online!

Spiegazione:

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

Versione più leggibile: provala online!

Restituirà sempre 1 o 2 anatre.

— user202729
fonte
Congratulazioni! Non ho letteralmente idea di come funzioni!
— AJFaraday,
@AJFaraday Sono andato avanti e ho aggiunto una spiegazione per te
— PunPun1000
@ PunPun1000 Siamo spiacenti, ma qual è lo stack? Jelly è un linguaggio di programmazione tacito.
— user202729
@ user202729 Spiacenti, ho Jelly e 05AB1E incasinati nella testa, potresti modificarlo per correggere l'errore? Mi dispiace per questo
— PunPun1000
C'è una concatenazione implicita in Jelly? Sìì!
— MilkyWay90
43

Operazione linguaggio di scripting Flashpoint , 48 byte

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

Stampa sempre una o due anatre.

random 1restituisce un numero (in virgola mobile) compreso tra 0 e 1. Tale numero viene passato come argomento a selectinsieme all'array [s,""]. Il numero casuale viene quindi arrotondato al numero intero più vicino (0 o 1) e l'elemento di matrice in corrispondenza di tale indice viene selezionato dalla matrice.

Chiama con:

hint call f

Produzione:

Versione alternativa a 56 byte:

f={s="duck\n";format[s+"%1goose",[s,""]select random 1]}
— Steadybox
fonte
3
Mi fa sempre piacere quando qualcuno lo usa su PCG.
— Nit
Beh, ho dimenticato che esisteva questo gioco.
— Caimen
38

World of Warcraft 81 byte

Ecco una macro che puoi eseguire in World of Warcraft.

/run for x=1,random(1,9) do SendChatMessage("Duck") end; SendChatMessage("Goose")
— Kelly Lowder
fonte
11
Oh mio signore ... Perché non ci ho mai pensato.
— Magic Octopus Urn
4
PVCG (Programmazione di videogiochi e Code Golf). L'operazione Flashpoint era una cosa, ma WoW? Sto aspettando le soluzioni Minecraft e Factorio di questo.
— Brain Guider
2
@AnderBiguri Sospetto che quello di Minecraft farebbe un po 'peggio di 81 byte (blocchi?);)
— Chris
5
Questo dovrebbe funzionare e /run for x=1,random(1,9)do print("Duck")end print("Goose")
— portarti
35

Minecraft <1.13, 72 54 byte

Scusa, ho dovuto.

Istruzioni:

  • Crea un nuovo mondo Minecraft in modalità Creativa
  • Trova la cartella di salvataggio per quel mondo e inserisci il seguente codice data/functions/minecraft/ddg.mcfunction
  • Esegui /function ddgnella console di gioco

Come funziona:

Emette la parola "papera" per ogni entità del mondo, quindi la parola "oca". Poiché le entità si generano e scompaiono costantemente, il numero di "anatre" non sarà coerente. Ho usato tellrawinvece il molto più breve sayperché sayrestituisce il nome dell'entità, mentre tellrawrestituisce esattamente ciò che viene detto.

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

Immagine dello schermo

inserisci qui la descrizione dell'immagine

Modifica: modificato {"text": "duck"} in "duck" (e lo stesso con "goose")

— FlyingPiMonster
fonte
1
Bellissimo. Abbiamo bisogno di più Minecraft in PPCG.
— BradC
9
Vale la pena ricordare che tu (il giocatore) sei un'entità nel mondo, quindi il numero di anatre non può mai essere 0 (anche se non c'erano mob ostili o passivi).
— BradC
1
@BradC ci dovrebbero essere intere sfide basate su Minecraft.
— tox123
17

JavaScript, 45 44 42 39 37 byte

Ha il potenziale per produrre un errore di overflow.

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

Provalo

o.innerText=(
f=_=>`duck
${new Date%2?f():`goose`}`
)()
<pre id=o></pre>
Espandi frammento

— ispido
fonte
14

Ottava , 38 33 byte

Questo non è il più breve (è di 36 byte), ma è il mio preferito. La spiegazione è in fondo.

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

Provalo online!

Alcune varianti più brevi:

Funziona in linea di principio (33 byte), ma gli interpreti online scadono:

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

L'aggiunta di alcuni byte per rendere più breve l'output lo rende 35 o 36 byte:

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

Spiegazione:

Spiegherò solo l'ultimo casuale. Gli altri sono simili, ma utilizza il numero di giorni dal 1 ° gennaio 0000 ad oggi.

randrestituisce un numero casuale sull'intervallo (0, 1) . Pertanto, 1/randrestituisce un numero maggiore di 1 . Poiché un intervallo 1:f, dove fè un float casuale maggiore di 1 è identico a 1:floor(f), 1:1/randcrea un intervallo 1 .. x , dove x> = 1 .

Proverò a spiegarlo come se Octave fosse un linguaggio basato sullo stack. 

      '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.
— Stewie Griffin
fonte
disp(['duck '+~pwd';'goose'])? Non sono sicuro che sia abbastanza "indeterminato"
— Luis Mendo,
12

Perl 5 , 20 byte

Prima un pratico 26 byte:

Anatre da 1 a 9 volte prima di essere beccato.

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

Provalo online!

Ma se hai molta memoria e tempo questa versione da 20 byte (come suggerito da Chris ) funziona anche:

say"Duck
"x$^T,Goose

Ciò presuppone anche che il problema dell'anno 2038 sarà risolto per Perl 5 , altrimenti non sarà più valido per 1 secondo 20 anni.

— Ton Hospel
fonte
Se cambi 1+$^T%9in just $^T, funziona ancora e risparmi 4 byte.
— Chris,
@chris Ovviamente hai più memoria di me. Prenderò comunque il tuo suggerimento poiché ci sono computer ragionevoli su cui funzionerà. Grazie.
— Ton Hospel,
12

Python 2 , 36 34 byte

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

Provalo online!

Il suggerimento di Kevin Cruijssen ci porta a 34 byte:

print"duck\n"*-~(id(id)%5),"goose"
— Greg Fuller
fonte
3
Benvenuti nel sito e bella prima risposta!
— caird coinheringaahing
Benvenuti in PPCG! Puoi giocare a golf di due byte cambiando ((id(id)%5)+1)in -~(id(id)%5)per sbarazzarti della parentesi. Suggerimenti per giocare a golf in <tutte le lingue> e Suggerimenti per giocare a golf in Python potrebbero essere interessanti da leggere. Goditi la permanenza!
— Kevin Cruijssen,
1
Non id(id)posso essere id(0)o mi sto perdendo qualcosa?
— Jonathan Frech,
@Johnathan, guardando id(0)su un paio di computer diversi suggerisce che è una costante.
— user2699
1
Leggermente più intuitivo e non ci sarebbero più byte da chiamare id([]). Ciò dovrebbe inizializzare un elenco distinto ogni volta che il programma viene eseguito, il che in teoria dovrebbe comportare coerentemente indirizzi di memoria diversi.
— jpmc26,
11

Z Shell (+ wget e Netpbm), 168 160 150 148 145 135 120 byte

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

Non è la soluzione più breve, ma mi è venuta voglia di dare una svolta a questa sfida (ispirata dalla soluzione di @ AlexG a questo altro problema ).

Questo script genera un'immagine PPM contenente tra 1 e 8 immagini di anatre e una foto di un'oca in fondo allo standard output. Scarica le due immagini di origine da Wikipedia, quindi è necessario l'accesso a Internet per funzionare.

Output di esempio convertito in JPEG tramite pnmtojpeg :

inserisci qui la descrizione dell'immagine

— lucasb
fonte
1
Questo ha reso la mia giornata totalmente!
— AJFaraday,
Mi sono appena reso conto che sei la stessa persona che ha proposto l'altra sfida a cui mi sono legata. xD Beh, sono contento che ti sia piaciuto! = D
— lucasb,
Sì, ci sono alcuni temi nelle mie sfide di golf del codice :) Dovrei assolutamente dare punti bonus per le risposte pittoriche.
— AJFaraday,
Non è una scappatoia standard per ottenere risorse esterne?
— MilkyWay90,
10

R , 35 byte

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

Provalo online!

rexp()produce un numero casuale da una funzione di decadimento esponenziale. +1per garantire almeno un'anatra. Tutte le righe successive alla prima includono uno spazio iniziale (che è il separatore predefinito per cat) ma questo è consentito.

— user2390246
fonte
1
La probabilità di produrre più di un'anatra è pari exp(-1)o intorno al 36,8%.
— Giuseppe,
Chiede di stamparlo su ogni riga. Penso che dovresti aggiungere "\ n" alla tua "papera"
— stuart stevenson,
3
@stuartstevenson Qui ho usato una nuova riga letterale piuttosto che \nun byte più breve. Se visiti il ​​"Provalo online!" link puoi vedere che l'effetto è lo stesso.
— user2390246
In una casella DOS / Windows, quella nuova riga sarebbe ancora due (2) byte. 0x0d0a
— acceso
10

Bash , 39 38 37 byte

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

Provalo online!

Stampa un numero di anatre pari al numero di cifre in un numero intero uniformemente distribuito su [0,32767] (quindi, più spesso, cinque anatre (un buon numero di anatre)).

-1 byte ciascuno grazie a @Chris e @sch sottolineando coppie di virgolette che non stavano tirando il loro peso.

— Sophia Lechner
fonte
1
Benvenuti in PPCG!
— Steadybox
1
È possibile salvare un byte per sbarazzarsi dei singoli apici finché si sostituisce \ncon \\n.
— Chris,
1
Bella idea Puoi fare qualcosa di simile con solo bash costrutti e senza sed per 30 byte.
— Trauma digitale
1
sed s/[0-9]/duck\\n/g<<<$RANDOM\goosepuò radere via un byte
— sch
1
Non sedè del tutto portatile. Su alcune piattaforme potresti cavartela con una singola barra rovesciata \n. Su altri non otterrai una nuova riga, qualunque cosa tu faccia.
— Tripleee
9

Pure Bash (senza utility esterne), 25

Basato sulla risposta di @ SophiaLechner , questo stampa anche un buon numero di anatre .

L'idea di @ OlivierDulac di utilizzare il PID della shell di script memorizzato nel $parametro consente di risparmiare 5 byte.

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

Provalo online .

— Trauma digitale
fonte
1
se assumiamo che avvii un programma, ogni volta riceverà un pid diverso. molte volte saranno lunghe 5 cifre, ma non sempre. quindi: passare RANDOMa $radere 5 byte? E si potrebbe anche fare una lunghissima serie di anatre:yes duck|head -n $$;echo goose
— Olivier Dulac
@OlivierDulac sì, penso che l'uso $$sia accettabile - grazie!
— Trauma digitale
prego! Ho pubblicato la mia altra versione ( yes duck | head -n $$;echo goose) come alternativa (più lunga della tua, ma si ottengono MOLTE anatre per 5 caratteri extra ^^)
— Olivier Dulac
8

Bash + Coreutils, 36 27 byte

yes duck|sed $$q;echo goose

Stampa troppe anatre (tra 2 e cat /proc/sys/kernel/pid_max), quindi un'oca.

Risparmiato nove byte grazie a Digital Trauma e Olivier Dulac.

Provalo online! (ma tieni presente che potrebbe essere troncato di tanto in tanto)

Stessa lunghezza, ma senza echo:

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

Provalo online!

aè il comando append in seded qesce. Entrambi funzionano solo sulla linea $$, che corrisponde al PID.

— Chris
fonte
Bash ha un modulo, anche se questo aumenterà la dimensione. Provahead -n $((1+(RANDOM % 5)))
— tripleee
@tripleee Poiché si tratta di code golf, è preferibile aumentare le dimensioni dell'output rispetto a quelle del codice. E 132767 anatre è decisamente ragionevole rispetto al miliardo o più che vedi altrove;)
— Chris
1
Certo, spero solo di essere utile nel caso qualcuno voglia davvero applicare questa ricerca rivoluzionaria in pratica un giorno. Come, TIO . 44 byte con alcuni spazi eliminati.
— Tripleee
@OlivierDulac ha suggerito di utilizzare $$invece di $RANDOMper la mia risposta . Penso che potresti usare lo stesso per risparmiare 5 byte. Oh e prova sedanche:yes duck|sed 1$$q;echo goose
— Digital Trauma
In realtà yes duck|sed $$q;echo gooseva bene - non credo che la tua sceneggiatura otterrebbe mai un PID <1.
— Digital Trauma
7

PowerShell , 35 30 28 byte

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

Provalo online! (versione modificata)

Genera una matrice di Get-Randomnumero di elementi. Potrebbe volerci un po '. Questo aggiunge un +1per assicurarci di averne almeno uno duck. La versione modificata include anche un -maflag ximum in 5modo da poter vedere il programma funzionare come previsto (la versione modificata stamperà 1, 2, 3 o 4 ducks prima del goose).

L'array e la goosestringa solitaria vengono lasciati sulla pipeline e l'implicito Write-Outputci fornisce gratuitamente valori separati da newline.

Non sai quanto sia stato difficile per me non modificare l'ultima riga in "anatra grigia" ...

— AdmBorkBork
fonte
Quella variante sembra piuttosto divertente, e sicuramente merita una sfida con il codice ... Ti consiglio di aspettare un paio di giorni e pubblicarla come una sfida tutta tua :)
— AJFaraday,
1
@AdmBorkBork, questo Minnesotan si è unito a questo gruppo per fare +1 sulla tua anatra grigia.
— Milwrdfan,
0..(random)|%{'duck'};'goose'sembra un 29 e genererà anche da qualche parte fino a [int] :: MaxValue (2,1 miliardi) di anatre prima di un'oca. (E 0..0stampa un'anatra)
— Tessellating Heckler
@TessellatingHeckler Grazie, ma proprio ora ho inventato una versione da 28 byte. :)
— AdmBorkBork
6

Brachylog , 24 21 byte

-3 byte grazie a Erik the Outgolfer

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

Provalo online!

Per celebrare la lingua del mese , il mio primo post su brachylog. Il flusso di controllo in questa lingua è interessante.

Come funziona:

"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
— PunPun1000
fonte
Quindi, se sto leggendo questo diritto, si legge da sinistra a destra, dal basso verso l'alto?
— AJFaraday,
2
Il linguaggio tenta di trovare una verità logica usando solo la prima riga del programma. Il mio programma dice "Convalida la seconda riga, quindi stampa oca". Quindi la seconda riga dice "stampa duck, quindi convalida un numero casuale da 0 a 4 è 0, o convalida di nuovo questa riga", quindi tecnicamente da sinistra a destra solo la riga superiore, quindi qualsiasi predicato che chiami da lì
— PunPun1000
Fantastico, è così interessante scoprire come funzionano le nuove lingue. Ha raggiunto la mia casella di posta, ma non sono sicuro che sia perché ho posto la domanda o perché avevo già commentato qui.
— AJFaraday,
Puoi unire i due predicati in questo modo e legarmi.
— Erik the Outgolfer,
6

Geometry Dash World 2.2 Editor - 4 oggetti

Immagine di Geometry Dash Level

Spiegazione:

Il trigger BG è il trigger casuale dell'attuale 2.2, quindi attiva o disattiva l'ID gruppo 1 o 2.

Il primo "DUCK" ha un ID di gruppo pari a 1, che ha una probabilità del 50% di essere rimosso o meno (attivato).

Non esiste alcun oggetto con l'ID gruppo 2 in questo livello, quindi esiste una probabilità del 50% di visualizzare 2 "DUCK".

Come riprodurre questo:

Il primo "DUCK" ha un ID gruppo di 1.

inserisci qui la descrizione dell'immagine

Goose e 2nd duck non hanno un ID gruppo inserisci qui la descrizione dell'immagine

All'interno del grilletto casuale. inserisci qui la descrizione dell'immagine

— MilkyWay90
fonte
Sento un tema per questa sfida
— Benjamin Urquhart il
@BenjaminUrquhart Cosa?
— MilkyWay90,
Ci sono proposte per Word of Warcraft, Minecraft e altri giochi.
— Benjamin Urquhart, il
2
@BenjaminUrquhart Meglio trovare altri giochi a cui rispondere
— MilkyWay90,
5

05AB1E , 15 14 byte

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

Provalo online!

Stampa 2, 5 o 6 anatre e poi oca.

-1 byte grazie a @Emigna usando 'per una singola parola compressa (duck)

— Kaldo
fonte
1
Puoi usare 'Ðœpoiché duck è una sola parola.
— Emigna,
1
Batte il mio:['ÐœTΩ#].•zíΘ•»
— Magic Octopus Urn
@MagicOctopusUrn Mi piace molto il tuo approccio a ciclo infinito. La tua risposta è sicuramente più nello spirito della sfida (o cosa avrebbe dovuto essere?) Dal momento che può produrre una quantità infinita di anatre.
— Kaldo,
@Kaldo ancora, 15 byte perdono i tuoi;)
— Magic Octopus Urn
1
Alternatore 14-byter:'Ðœ₁Ω.D.•zíΘ•»
— Magic Octopus Urn
5

Retina , 17 byte

?\\K`duck
K`goose

Provalo online!

Provalo online!

Stampa 1 o 2 anatre, con uguale probabilità.

Spiegazione

?\\K`duck

Impostare la stringa di lavoro su ducke stamparla con un trascinamento di riga ( \). Quindi questo è racchiuso in un altro stadio di output, ma questo ha il flag casuale ( ?) applicato ad esso, quindi stampa solo con una probabilità del 50%.

K`goose

Sostituisci duckcon goose, che viene stampato implicitamente alla fine del programma.

Ecco una divertente alternativa che stampa 1 anatra con il 50% di probabilità, 2 anatre con il 25%, 3 anatre con il 12,5% ...:

\K`duck
?+\G`
K`goose
— Martin Ender
fonte
5

Vim (script) su Linux, 46 43 byte (4946 con :all'inizio della riga)

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

Eseguito come vim -S filenameo incollato in esecuzione vimcon :prima di ogni riga.

— jiwopene
fonte
2
Benvenuti in PPCG! Dovresti essere in grado di utilizzare \doltre [0-9]. Inoltre, sembra che Vim non richieda la nuova riga finale, quindi questo può essere di 45 byte :)
— H.Pwiz
Benvenuti in PPCG!
— Steadybox
5

> <> , 31 22 byte

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

Provalo online!

-9 byte in base alla revisione di Non un albero

— KSmarts
fonte
1
È possibile rimuovere l?!;ed uscire con un errore.
— Emigna,
1
E si potrebbe risparmiare un po 'più simile a questa
— Emigna
1
O come questo .
— Non un albero il
3
@Notatree Ottengo quello a volte stampare "\ nkcud \ nkcud ...". Raramente si comporta correttamente
— Suppen
1
@Suppen Risolve semplicemente usando una freccia anziché un mirror; vedi modifica.
— KSmarts,
5

Befunge 98 , 38 30 25 byte

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

Provalo online!

  • Grazie @JoKing per aver rimosso l'inutile trampolino
  • Passare a Befunge 98 per una nuova linea più corta - ora Duckrientra in una singola stringa
— Vincent
fonte
1
Non hai bisogno della #seconda riga
— Jo King,
E "tecnicamente", whitespace within a line is finequindi puoi ritagliare un paio di virgolette (anche se l'output sembra strano)
— Jo King
@JoKing Grazie, guarda la mia modifica.
— Vincent,
5

T-SQL , 70 44 43 byte (molte anatre)

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

Grazie @Zac Faragher!

Versione rivista, 54 43 40 byte (1 o 2 anatre)

Grazie @BradC!

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


Non riesco a farlo funzionare correttamente in SQL Fiddle , ma funziona perfettamente in LINQPad e SSMS.

Non sono sicuro se questa è una limitazione nota di SQL Fiddle o sto solo facendo qualcosa di sbagliato

— Probabilmente
fonte
Bello. Giù per 61 se si cambia selectper printe sostituire la finale 'duck'select'goose'con 'duck(linebreak)goose'(con un'interruzione di riga letterale, ovviamente)
— BradC
In realtà, puoi solo fare while rand()<.5print'duck'print'duck(linebreak)goose'per 43.
— BradC
Bene, grazie @BradC. C'è un altro modo per rappresentare un'interruzione di riga in una stringa oltre all'aggiunta di un carattere (13)?
— Probabilmente il
Sì, ho letteralmente messo un ritorno tra le virgolette, modificherò il tuo post per mostrarti (i commenti non mostrano i ritorni).
— BradC,
1
Salva altri 3 byte: cambia il primo whilein if. Stampa (in modo casuale) un'anatra o due, che (credo) soddisfa ancora la sfida.
— BradC,
5

Powershell - 31 30 byte

Attenzione : molto probabilmente finirai con un sacco di anatre. Randominclude i valori da 0 a Int32.MaxValuecosì, a seconda di quanto sia casuale il tuo numero, questo potrebbe essere un sacco di quacking.

1..(Random)|%{"Duck"};"Goose"
— SomeShinyObject
fonte
Non dovresti aver bisogno $di davanti (Random). Provalo online!
— AdmBorkBork
@AdmBorkBork grazie per la cattura!
— SomeShinyObject
4

Befunge

57 35 byte (il perimetro dell'intero campo è 19x3 17x2 caratteri) Grazie a karhell per il miglioramento.

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

La seconda riga mette anatra e una nuova riga sullo stack (all'indietro) e la emette come una stringa. Dopo quella probabilità del 75% di tornare all'inizio e stampare di nuovo l'anatra, il 25% (quando il punto interrogativo decide di scendere) per stampare l'oca e fermarsi.

— rael_kid
fonte
Se una probabilità del 50% di oca è accettabile, 55+"kcud",,,,,#v?(linebreak here) @,,,,,"goose"< ridurrebbe il codice a 35 byte
— karhell
Ah il dolce avvolgente. Hai ragione, grazie, posterò un aggiornamento più tardi!
— rael_kid,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.