99 bug nel codice

L'adattamento di "99 bottiglie di birra al muro" per l'informatica in cui aumentano i bug invece che diminuiscono le bottiglie viene spesso ripubblicato su Internet. Esempio di maglietta qui .

Penso che sarà interessante vedere la potenziale ricorsione e la generazione casuale di numeri in una grande varietà di lingue e trovare i modi più efficienti per farlo.

Ci sono alcune altre sfide da fare con 99 bottiglie di birra, ma nessuna sembra avere un numero crescente e decrescente!

Sfida

Il programma o la funzione non devono ricevere input e quindi stampare

99 bug nel codice

99 bug nel codice

Prendi uno e patch intorno

X bug nel codice

(riga vuota)

Dove X è il numero intero precedente meno 1 più un numero intero casuale nell'intervallo [-15,5].
È possibile unire il meno 1 nell'intero casuale, consentendo quindi l'intervallo [-16,4].
Gli intervalli possono essere esclusivi, quindi meno uno più (-16,6) o (-17,5).

Gli interi casuali non devono essere distribuiti uniformemente, devono solo essere tutti possibili.

Il programma inizia sempre con 99 bug.

È possibile ignorare l'errore grammaticale di "1 bug".

Il programma dovrebbe arrestarsi quando il numero di bug è 0 o negativo e stampa

0 bug nel codice

Non dovrebbe mai esserci un numero negativo di bug. Il finale dovrebbe assomigliare

Y bug nel codice

Y bug nel codice

Prendi uno e patch intorno

0 bug nel codice

(riga vuota)

0 bug nel codice

Una nuova riga finale è accettabile.

• Il tuo codice può essere un programma completo o una funzione.
• Non ci sono input.
• L'output dovrebbe essere stdout o restituito.
• Avvisi / errori nei registri / STDERR sono validi fintanto che STDOUT ha il testo richiesto. Vedi qui per maggiori informazioni.

Questo è code-golf quindi vince il codice più breve in byte.

Esempio di output

Incolla l'output di esempio del bin truccato ogni volta per -11 bug

R , 182 140 138 135 byte

n=99;while(n)cat(n,b<-" bugs in the code
",n,b,"take one down and patch it around
",n<-max(0,n-sample(21,1)+5),b,"
",c(n,b)[!n],sep="")

Provalo online!

pur essendo ragionevolmente bravo a generare numeri casuali, R è terribile nelle stringhe e nella stampa. JayCe ha trovato circa un miliardo di byte e continua a trovare nuovi modi per giocare a golf!

Java 8, 161 160 byte

v->{String s="",t=" bugs in the code\n";for(int i=99;i>0;s+=i+t+i+t+"Take one down and patch it around\n"+((i-=Math.random()*21+4)<0?0:i)+t+"\n");return s+0+t;}

-1 byte grazie a @JonathanAllan .

Provalo online.

Spiegazione:

v->{                   // Method with empty unused parameter and String return-type
  String s="",         //  Result-String, starting empty
         t=" bugs in the code\n";
                       //  Temp-String we use multiple times
  for(int i=99;i>0;    //  Start `i` at 99, and loop as long as it's larger than 0
    s+=                //   Append to the result-String:
       i+t             //    The first line of the verse
       +i+t            //    The second (duplicated) line of the verse
       +"Take one down and patch it around\n"
                       //    The third line of the verse
       +((i-=Math.random()*21-4)
                       //    Decrease `i` by a random integer in the range [-16, 4]
         <0?0:i)       //    If `i` is now negative, set it to 0
        +t+"\n");      //    And append the fourth line of the verse
  return s             //  Return the result,
         +0+t;}        //  appended with an additional line for 0 at the very end

PowerShell , 137 135 133 131 byte

$b=' bugs in the code';for($a=99;$a){,"$a$b"*2;"Take one down and patch it around";$a+=-16..4|Random;if($a-lt0){$a=0}"$a$b`n"}"0$b"

Provalo online!

La sezione "bug nel codice" viene salvata $bper un uso successivo. Imposta $asu 99, forattiva un loop $a. Per prima cosa creiamo un array di due stringhe ," "*2, con la stringa che è il "X bugs in the code".

Il prossimo è solo la stringa "Take one down and patch it around". Quindi incrementiamo $aselezionando un Randomnumero intero dall'intervallo [-16,4]. Dopodiché, fissiamo $aun valore minimo di zero usando un if if($a-lt0){$a=0}. Quindi la stringa "Y bugs in the code".

Alla fine, dopo che il ciclo è terminato, mettiamo la stringa "0 bugs in the code"sulla pipeline. Tutte queste stringhe vengono raccolte dalla pipeline e un implicito Write-Outputci fornisce nuove linee tra loro gratuitamente.

Salvati due byte usando un forloop anziché un whileloop.
Salvato due byte spostandosi $bnella propria sezione.
Risparmiato due byte grazie ad Adrian Blackburn.

JavaScript (Node.js) , 127 byte

f=(i=99,t=` bugs in the code
`)=>i>0?i+t+`Take one down and patch it around
`+((i+=0|Math.random()*21-15)<0?0:i)+t+`
`+f(i):0+t

Provalo online!

Spiegazione :

f = (                                          // start of our recursive function
    i=99,t=` bugs in the code                 // parameters, 1. num bugs , 2. text
`)                                           // using string literal end text with \n
=>                                          // start function
    i > 0 ?                                // if i is greater than 0
        i + t +                           // return value of i, value of t and  
    `Take one down and patch it around   // and this text 
    `                                   // + new line
    + (( i +=                          // and add 
        0|Math.random()*21-15) < 0 ?  // remove decimal from value obtained by multiplying
                                     // random number (between 0 and 1) multiplied by 21 
                                    // and then subtracting 15 from it
                                   // if that value is less than 0
        0 :                       // add 0 to i
        i                        // otherwise add value of i  
        )                       // end the parenthesis 
    + t                        // add value of t to that
    + `\n`                    // along with a new line 
    + f(i)                   // and repeat the process (this is recursive)
    :                       // if i > 0 condition not met then
        0 + t              // return 0 + t. Zero is there so the last line can be 
                          // repeated

Grazie a @tsh per l'idea di ricorsione e implementazione (salvati alcuni byte)

Eventuali suggerimenti per giocare a golf sono benvenuti.

05AB1E , 59 byte

99[Ð16(4ŸΩ+¾‚{θ©3F“ÿ±À€†€€ƒË“Š}“ƒ¶€µ„‹€ƒš¡€•…¡“ªsõ®>#®]sDŠ»

Provalo online!

Python 2 , 151 byte

Bel trucco j=i+max(-i,randint(-16,4))di Jo King, lo sfruttamento ha permesso una distribuzione irregolare

Byte salvati di coppia grazie a Mnemonic

from random import*
i,s=99,'bugs in the code\n'
while i:j=max(0,i+randint(-16,4));print i,s,i,s,'Take one down and patch it around\n',j,s;i=j
print i,s

Provalo online!

Carbone , 81 byte

≔⁹⁹θ≔”⧴"pWº⁴tＳn/{yBⅈ⁺”ζＷ›θ⁰«×²﹪ζθ”↶0⪫\`3+¤⸿Zν(z¬hＬÀＴj'ZXεＰraF”≧⁺⁻⁴‽²¹θ﹪ζ×θ›θ⁰¶»﹪ζ⁰

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

≔⁹⁹θ

Inizia con 99 bug nel codice.

≔”⧴"pWº⁴tＳn/{yBⅈ⁺”ζ

Salvare la stringa compressa "% d bugs nel codice \ n".

Ｗ›θ⁰«

Ripeti finché è rimasto un numero positivo di bug.

ײ﹪ζθ

Stampa il numero di bug nel codice due volte.

”↶0⪫\`3+¤⸿Zν(z¬hＬÀＴj'ZXεＰraF”

Stampa "Prendi uno in basso e rattoppalo".

≧⁺⁻⁴‽²¹θ

Aggiungi un numero casuale di bug tra -17 (esclusivo) e 4 (incluso).

﹪ζ×θ›θ⁰

Stampa il numero di bug rimanenti o 0 se negativo.

¶

Lascia una riga vuota tra i versi.

»﹪ζ⁰

Dopo l'ultimo versetto, stampa di nuovo 0 bug nel codice.

JavaScript, 189 176 168 162 byte

f=(x=99)=>{c=console.log;m=Math;a=` bugs in the code
`;c(x+a+x+a+"Take one down and patch it around"+(x=m.max(x+m.ceil(m.random()*21-15),0))+a)
x?f(x):c(`
`+x+a)}

Provalo online!

Grazie per Muhammad Salman per la console.logsostituzione mancante e per Oliver per il miglioramento del test x

Grazie per l4m2 per giocare a golf di 8 byte

Python 3 , 156 138 byte

Grazie alla risposta di Jonathan Python 2 per il idtrucco

r=n=99
z='%d bugs in the code\n'
while n:x=n;r+=id(r);n-=min(n,r%21-4);print((z%x)*2+'Take one down and patch it around\n'+z%n)
print(z%n)

Provalo online!

Spiegazione:

r=n=99       #Initialise r and n to 99
z='%d bugs in the code\n'  #Save n
while n:     #Loop while n is not 0
    x=n      #Save value of n
    r+=id(r) #Modify value of r, which changes the hash value
    n-=min(n,r%21-4)  #Change n's value by a random number between 4 and -16
    print((z%x)*2+'Take one down and patch it around\n'+z%n)   #Print the message
print(z%n)  #And print the final line

Ottava , 149 148 byte

Salvato un byte cambiando randi(21)e %iin 21*rande %.f. %.fassicura che l'output sia un float con zero decimali (cioè e intero).

Inserito un gruppo di interruzioni di riga anziché virgole e punti e virgola per facilitare la leggibilità. Sembra sbagliato, ma non è più lungo del one-liner.

x=99;do(p=@(i)printf('%.f bugs in the code\n',i))(x)
p(x)
disp('Take one down and patch it around')
p(max([0,x+=21*rand-17]))
disp('')until x<1
p(0)

Provalo online!

Spiegazione:

x=99;               % Initialize the number of bugs to 99
do ...  until x<1   % Loop until the number of bugs is less than 1
 (p=@(i)printf('%.f bugs in the code\n',i))(x)  % Create a function handle p that takes
                                                % the number of bugs as input and outputs
                                                % the string x bugs ... \n
 p(x)                % Call that function with the same number of bugs to get two lines
 ,disp('Take on down and patch it around')       % Outputs that line, including a newline
 ,p(max([0,x+=21*rand-17]))                    % Call p again, while updating the number
                                                 % of bugs. The number of bugs will be 
                                                 % the old one plus the random number, or 0
                                                 % if it would have turned negative
 ,disp('')        % A newline
p(0)              % Finally, the last single line.

Usando p((x+=21*rand-17)*(x>0)invece di maxsalva un byte, ma l'ultima riga viene emessa -0 bugs ...invece di 0 bugs. Funziona con randi(21)-17, ma poi ha la stessa lunghezza di quello sopra. Provalo online!

COBOL (GnuCOBOL), 317 294 279 270 byte

data division.working-storage section. 1 i pic S99 value 99.procedure division.perform until i=0 perform a 2 times display"Take one down and patch it around"compute i=i-(random*21- 4)if i<0 compute i=0 end-if perform a display""end-perform.a.display i" bugs in the code"

Provalo online!

Ungolfed

data division.                     <-- Define the variables we want to use
working-storage section.           <-- Define global variables used in this
                                       program

1 i pic S99 value 99.              <-- Define variable i with datatype signed
                                       numeric and with two digits

procedure division.                <-- Define our program

perform until i = 0                <-- Perform the following code until i = 0
    perform a 2 times              <-- Execute the procedure called 'a' twice,
                                       see below

    display "Take one down and patch it around"   <-- Display this sentence
    compute i = i -                <-- Subtract from i some random value
        (random * 21 - 4)

    if i < 0                       <-- if i < 0
        compute i=0                <-- then assign 0 to i
    end-if
    perform a                      <-- Execute the procedure 'a'
    display ""                     <-- Display an empty string; needed because
                                       of the blank line
end-perform.

a.                                 <-- Define procedure called 'a'.
    display i " bugs in the code"  <-- Display the value of i and then the
                                       given string literal

Nota: l'ultima frase è ancora stampata, perché COBOL esegue l'intero programma e dopo il perform untilciclo "scorre" l'etichetta a , eseguendo le sue istruzioni. Questo comportamento è simile a un switch casesenza break.

PS: I numeri non vengono visualizzati esattamente come richiesto, ma COBOL non è così bravo a convertire automaticamente i numeri in una rappresentazione piuttosto testuale.

VBA: 212 163 byte

Questa soluzione si basa su quella di Chronocidal pubblicata ieri. Questo è il mio primo post e non ho abbastanza reputazione per commentare il suo post.

Questa revisione contiene due miglioramenti.

1. Usando While/Wendinvece di For/Nextsalva alcuni caratteri.
2. La chiamata di un Sub con un singolo carattere è più breve di GoSube le linee Exit Sube Returnnecessarie per supportarlo.

Modifica:
3. Rimossi spazi bianchi e caratteri che l'editor VBA aggiungerà di nuovo automaticamente. Vedi Suggerimenti per giocare a golf in VBA
4. Aggiunti suggerimenti da @EricF, quindi ho visto che il suo algoritmo del cestino era ancora più piccolo, quindi ho sostituito il mio algoritmo con il suo e rimosso spazi bianchi. Una modifica della chiave è stata aggiunta vbLFalla stringa di output, quindi Debug.Printnon è stato necessario chiamarla spesso. Complimenti a EricF .

Sub b()
s=" bugs in the code"&vbLf
c=99
While c
Debug.? c &s &c &s &"Take one down and patch it around
c=c+5-Int(Rnd()*20)
c=IIf(c<0,0,c)
Debug.? c &s
Wend
End Sub

Questa è stata una sfida divertente. Se conosci un interprete online come TIO per VB6 / VBScript / VBA, lascia un commento.

Se vuoi testare questo codice e hai installato Microsoft Excel, Word, Access o Outlook (solo Windows), premi Alt + F11 per aprire l'IDE VBA. Inserisci un nuovo modulo di codice (Alt + I, M) e cancella Option Explicit. Quindi incolla il codice e premi F5 per eseguirlo. I risultati dovrebbero apparire nella finestra immediata (premi Ctrl + G se non li vedi).

LaTeX , 368 304 293 287 245 240 byte

Sebbene non sia realmente competitivo rispetto agli altri programmi in termini di byte, volevo solo vedere come farlo in LaTeX.

\documentclass{proc}\newcount\b\b99\usepackage[first=-16,last=5]{lcg}\def~{\the\b\ bugs in the code\\}\def\|{\loop~~Take one down and patch it around\\\rand\advance\b\value{rand}\ifnum\b>0 ~\\\repeat\b0 ~\\~}\begin{document}\|\end{document}

Più leggibile:

\documentclass{proc}               %shortest document class
\newcount\b                        %short variable name
\b 99                              %set the value to 99
\usepackage[first=-16,last=5]{lcg} %random number generator
%\the prints the value of the variable behind it
%\def is shorter than \newcommand and can redefine commands
\def~{\the\b\ bugs in the code\\}
\def\|{                            %the function
    \loop
        ~
        ~
        Take one down and patch it around\\
        %\rand creates a counter named rand and                                        
        %stores the random value in it
        \rand \advance\b\value{rand} 
        %if the counter is smaller than 0, it becomes 0
        \ifnum\b>0 
            ~ \\                  %extra newline as required
    \repeat
    %if b is equal or smaller than 0, set it to 0
    \b 0 
    ~ \\                          %then print like normal
    %extra print at the end
    ~
}
\begin{document}
    \|                             %calling the function
\end{document}

Miglioramenti (per modifica):

1. "x bug nel codice" è ora una funzione anziché 4 righe
2. Riscritto la \ifclausola per \repeatas a\else
3. Apparentemente \value{b}=xfunziona per l'inizializzazione ma non nel loop (anziché \setcounter{b}{x})
4. Apparentemente \relaxdovrebbe essere usato per il punto 3, ma ciò può essere ottenuto anche inserendo uno spazio. Rimossi i \elsecomandi TeX utilizzati, anziché LaTeX poiché sono più brevi e sostituiti \'da ~.
5. Alcuni codici non hanno bisogno di essere rilassati per qualche motivo.

C,  169  165 byte

Grazie a @ceilingcat per aver salvato quattro byte!

*s=" bugs in the code";f(i,j){for(i=99;i>0;i=j)printf("%d%s\n%d%s\nTake one down and patch it around\n%d%s\n\n",i,s,i,s,(j=i+rand()%19-15)<0?0:j,s);printf("0%s",s);}

Provalo online!

SAS, 210 byte

%macro t;%let b=bugs in the code;%let a=99;%do%until(&a<=0);%put&a &b;%put&a &b;%put Take one down, pass it around;%let a=%eval(&a-%sysfunc(ranbin(0,20,.3))+4);%if &a<0%then%let a=0;%put&a &b;%put;%end;%mend;%t

Ungolfed:

%macro t;
%let b=bugs in the code;
%let a=99;
%do%until(&a<=0);
  %put &a &b;
  %put &a &b;
  %put Take one down, pass it around;    
  %let a=%eval(&a-%sysfunc(ranbin(0,20,.3))+4);
  %if &a<0%then%let a=0;
  %put &a &b; 
  %put;
%end;
%mend;
%t

Può salvare alcuni byte se sono consentiti avvisi nel registro (inserire il valore &anella &bvariabile macro, ma ciò genera un avviso iniziale).

PHP, 126 byte

Esegui dalla riga di comando, usando php -r 'code here':

$b=" bugs in the code
";for($x=99;print$x.$b,$x;)echo"$x{$b}Take one down and patch it around
",$x-=min($x,rand(-4,16)),"$b
";

ABAP , 295 byte

... perché non diamine!

REPORT z.DATA:a(16),c TYPE qfranint.a = 'bugs in the code'.data(b) = 99.WRITE:/ b,a.WHILE b > 0.WRITE:/ b,a,/'Take one down and patch it around'.CALL FUNCTION
'QF05_RANDOM_INTEGER' EXPORTING ran_int_max = 21 IMPORTING ran_int = c.b = b + c - 17.IF b < 1.b = 0.ENDIF.WRITE:/ b,a,/,/ b,a.ENDWHILE.

Non è certamente competitivo rispetto ad altre lingue, ma sono anche riuscito a ridurlo a 330 byte che ho scritto inizialmente, quindi lo considero una vittoria personale.

Poiché ABAP non consente righe più lunghe di 255 caratteri, ho dovuto sostituire uno spazio con un'interruzione di riga. Su Windows questo inizialmente aumentava la dimensione a 296 byte a causa di CRLF, ma funziona bene con solo l'LF. ABAP richiede sicuramente molti spazi, quindi questo non è un grosso problema.

WRITE semplicemente scarica il testo sulla GUI, quindi immagino che sia un po 'come stdout? Probabilmente potrei salvare alcuni byte qui usando una struttura o una tabella, ma a causa di come SAP gestisce strutture miste (contenenti caratteri e numeri) l'approccio che immaginavo avrebbe funzionato solo su sistemi non Unicode ... Che personalmente considero un no- vai, nonostante abbia accesso ad entrambi.

Il modulo funzionale per i numeri casuali è l'unico che ho trovato nel nostro sistema, suppongo che potrebbe essercene uno con un nome o parametri più brevi. Nessuna idea!

Codice più o meno leggibile, commenti inclusi:

REPORT z.
  "Define a (text) and c (random)
  DATA: a(16),
        c TYPE qfranint. "A stupid data type for a random INT

  "This is shorter than using VALUE (saves 3 bytes)
  a = 'bugs in the code'.
  "This is slightly shorter than doing ',b TYPE i' and 'b = 99'. (saves 2 bytes)
  data(b) = 99.

  "first line has to be outside of loop due to our exit condition (saved me ~5 bytes)
  WRITE: / b,a. "\n xx bugs in the code

  WHILE b > 0.
    WRITE: / b,a, "\n xx bugs in the code
    /'Take one down and patch it around'.

    "This ridiculous function for random numbers...
    "To save some bytes, I leave ran_int_min at it's default
    "of 1, and set the max to 21 instead, from which I remove
    "17 later on, resulting in a range of [-16,4]
    "Compare:
    "   ' - 17'              =  5 bytes
    "   ' ran_int_min = -16' = 18 bytes
    "(saves 13 bytes)

    CALL FUNCTION 'QF05_RANDOM_INTEGER'
        EXPORTING ran_int_max = 21
        IMPORTING ran_int = c.

    "Maximum number of bugs added:     4 = 21 - 17
    "Maximum number of bugs removed: -16 =  1 - 17
    b = b + c - 17.

    IF b <= 0.
        b = 0.
    ENDIF.

    WRITE: / b,a,/,/ b,a. "\nxx bugs in the code\n\nxx bugs in the code
  ENDWHILE.

Grazie per la sfida!
Al mio capo: Per favore, non licenziarmi, sto solo educando me stesso!

Pulito , 245 234 byte

import StdEnv,Math.Random,System.Time,System._Unsafe,Text
f[n,v:l]b|n>0=n<+b<+n<+b+"Take one down and patch it around\n"<+max 0v<+b+"\n"+f[v:l]b=0<+b

f(scan(+)99[n rem 20-16\\n<-genRandInt(toInt(accUnsafe time))])" bugs in the code\n"

Provalo online!

C #, 184 181 byte

La mia prima risposta da Code Golf!

(Basato sulla risposta Java di @Kevin Cruijssen)

Func<String>c=()=>{String s="",t=" bugs in the code\n";for(int i=99;i>0;s+=i+t+i+t+"Take one down and patch it around\n"+((i-=new Random().Next(21)-4)<0?0:i)+t+"\n");return s+0+t;};

Provalo online!

C (gcc) , 141 137 byte

Ho usato le macro del preprocessore per la massima giustizia (avviso: TV Tropes)

#define _(a)printf("%d bugs in the code\n"#a,i)
f(i){for(i=99;_(),i;i+=rand()%21-16,i*=i>0,_(\n))_(Take one down and patch it around\n);}

Provalo online!

T-SQL, 188 byte

DECLARE @ INT=99,@b CHAR(18)=' bugs in the code
'a:PRINT CONCAT(@,@b,@,@b,'Take one down and patch it around
')SET @+=5-22*RAND()IF @<0SET @=0PRINT CONCAT(@,@b,'
')IF @>0GOTO a;PRINT '0'+@b

SQL consente i ritorni all'interno dei valori letterali delle stringhe, quindi ciò aiuta.

CONCAT()esegue una conversione implicita in testo, quindi non devo preoccuparmi di CASTo CONVERT.

JavaScript, 138 byte

_=>(I=i=>`Take one down and patch it around
${l=(i>0?i:0)+` bugs in the code
`}
`+l+l+(i>0&&I(i+Math.random()*21-15|0)))(99).slice(55,-25)

f=

_=>(I=i=>`Take one down and patch it around
${l=(i>0?i:0)+` bugs in the code
`}
`+l+l+(i>0&&I(i+Math.random()*21-15|0)))(99).slice(55,-25)

console.log(f())

QB64 , 134 byte

Da mio fratello

S$="bugs in the code":I=99:WHILE I>0:?I;S$:?I;S$:?"Take one down and patch it around":I=I+INT(RND*21)-15:I=-(I>0)*I:?I;S$:?:WEND:?I;S$

Pyth , 94 92 byte

J99WJ%jb[K"%d bugs in the code"K"Take one down and patch it around"Kk)[JJ=JeS,Z+J-O21 16;%KZ

Provalo online

Versione precedente: 94 byte

J99WJp%jb[K"%d bugs in the code"K"Take one down and patch it around"K)[JJ=JeS,Z+J-O21 16)b;%KZ

Gelatina , 61 byte

;“,Ȥm46Ṛṛ⁽eɼḞF»
ÇȮ“"ḃḲɠ⁼ċTṪʠ/Ạ⁺ṗḍ^ẸƘⱮṖ8»20X+_«¥©17Ç⁷®ßÇ®?
99Ç

Un collegamento niladico che funziona anche come un programma completo.

Provalo online! (l'output viene svuotato al termine dell'esecuzione ma stampa paragrafo per paragrafo)

Come?

;“,Ȥm46Ṛṛ⁽eɼḞF» - Link 1, helper to construct count-text: number
 “,Ȥm46Ṛṛ⁽eɼḞF» - compressed string (list of characters) = " bugs in the code\n"
;               - concatenate the number with that list of characters

ÇȮ“"ḃḲɠ⁼ċTṪʠ/Ạ⁺ṗḍ^ẸƘⱮṖ8»20X+_«¥©17Ç⁷®ßÇ®? - Link 2, print stuff: number
Ç                                         - call the last Link (1) as a monad
 Ȯ                                        - print and yield that
                                          - ...at this point that is then printed again
                                          -    implicitly due to the start of a new leading
                                          -    constant chain below
  “"ḃḲɠ⁼ċTṪʠ/Ạ⁺ṗḍ^ẸƘⱮṖ8»                  - compressed string (list of characters)
                                          -     = "Take one down and patch it around\n"
                                          - ...once again an implicit print, same reason
                        20                - twenty
                          X               - random int from [1,20] 
                           +              - add the left argument, the number
                                17        - seventeen
                              ¥           - last two links as a dyad:
                             «            -   minimum (of rand[1,20]+n and 17) 
                            _             -   subtract
                               ©          - copy this newNumber to the register
                                  Ç       - call last Link (1) as a monad = f(newNumber)
                                          - here we get another implicit print, same reason
                                   ⁷      - a new line character
                                          - yet another implicit print, same reason
                                    ®     - recall newNumber from the register
                                        ? - if... 
                                       ®  - ...condition: recall from register again
                                          -               (i.e. if non-zero)
                                     ß    - ...then: call this Link (2) as a monad
                                          -          = Link 2(newNumber)
                                      Ç   - ...else: call the last Link (1) as a monad
                                          -          = Link 1(0) (since newNumber=0)

99Ç - Main Link: no arguments
99  - yep, you guessed it, ninety nine
  Ç - call the last Link (2) as a monad

Perl, 132 byte

$c=" bugs in the code
";for($i=99;$i>0;$i+=~~rand(21)-16){print$t.$/,($t=$i.$c)x2,"Take one down and patch it around
"}print"0$c
"x2

VBA: 225 233 byte

Sub b()
For c = 99 To 0 Step -1
GoSub d
GoSub d
Debug.Print "Take one down and patch it around"
c = c + 5 - Int(rnd() * 20)
If c < 0 Then c = 0
GoSub d
Debug.Print
Next c
Exit Sub
d:
Debug.Print c & " bugs in the code"
Return
End Sub

{EDIT} Aggiunti i mancantirnd()*

Note:
consente GoSubdi stampare la linea triplicata, poiché è leggermente più breve rispetto all'assegnazione della linea a una variabile e alla sua Debug.Printing.
Debug.Printsenza alcun argomento stampa una riga vuota (non è necessaria una stringa Null o vuota) Una WorksheetFunction.Maxriga sarebbe troppo lunga, quindi ho usato un "se meno di" per prevenire i negativi.

Con rientro e commenti

Sub b()
    For c = 99 To 0 Step -1
        GoSub d '"# bugs in the code"
        GoSub d '"# bugs in the code"
        Debug.Print "Take one down and patch it around"
        c = c + 5 - Int(rnd() * 20)
        If c < 0 Then c = 0 'Non-negative
        GoSub d '"# bugs in the code"
        Debug.Print
    Next c
    Exit Sub
d: 'This is our GoSub bit
    Debug.Print c & " bugs in the code"
    Return
End Sub

Python 2 ,  138 134 133 131  127 byte

-1 Grazie a Jo King (riorganizzare in modo da utilizzare la logica bugs-=min(bugs,randomNumber)anziché bugs=max(0,bugs-randomNumber)). Ciò ha consentito la chiusura forzata utilizzando una divisione per zero errori, salvando altri 6 byte!

r=n=99
t="bugs in the code\n"
while 1:r+=id(r);b=n;n-=min(n,r%21-4);print b,t,1/b|b,t,"Take one down and patch it around\n",n,t

Provalo online!

Rubino: 149 byte

n=99;f=" bugs in the code\n";loop{puts"#{n}#{f}"*2+"Take one down and patch it around\n";(n+=rand -16..4)>0?puts("#{n}#{f}\n"):break};puts"0#{f}\n"*2

Dovrebbe funzionare praticamente in qualsiasi versione di Ruby> = 1.8

Penso che potrebbe essere possibile ottimizzare un po 'di più le stringhe, ma in generale ne sono abbastanza soddisfatto, in particolare l'assegnazione combinata / confronto / interruzione e l'abuso di parentesi opzionali.

Nota: l'output ha tecnicamente due newline finali; se è necessario renderlo conto, aumenta di 4 caratteri.

Zsh , 133 byte

b="%d bugs in the code
";for ((n=99;n;)){printf $b$b"Take one down and patch it around
$b
" n n n-=RANDOM%21-4,n=n\>0\?n:0};printf $b

Provalo online!

Questo sfrutta alcune funzionalità di zsh.

• la forma del ciclo alternativo : while list; do list; donepuò essere scritta comewhile list {list}
• Se un identificatore di formato printfè numerico, l'argomento corrispondente viene valutato come espressione aritmetica. Così:
  • otteniamo il valore di ngratuitamente senza usare a$
  • n -= RANDOM % 21 - 4, n = n > 0 ? n : 0viene nuovamente valutata senza dover uso $((...)), $[...]o simili. L' >e ?doveva essere evaso.
  • Alla printf $bfine valuta un argomento vuoto come 0 per %d.
• La divisione delle parole sull'espansione dei parametri è disattivata per impostazione predefinita, quindi non devo fare virgolette da $bnessuna parte.
  • Questo mi permette di scrivere $b$b"Take..."invece di "$b${b}Take...".

• Salvato alcuni byte usando le nuove righe effettive anziché \ne for((n=99;n;))invece di n=99;while ((n)).