代码中的99个错误

在计算机科学中对“ 99瓶啤酒”的改编通常是在互联网上重新发布的，在这种计算机中，臭虫增加而不是减少了。示例T恤在这里。

我认为，看到各种各样的语言中潜在的递归和随机数生成并找到最有效的方法将很有趣。

99瓶啤酒还有很多其他挑战，但似乎没有一个越来越多！

挑战

您的程序或函数不应该输入任何内容，然后打印

代码中的99个错误

代码中的99个错误

取下并修补

代码中的X个错误

（空行）

其中X是前一个整数减1加[-15,5]范围内的随机整数。
您可以将负1合并为随机整数，从而允许范围为[-16,4]。
范围可以是互斥的，因此要减去一加（-16,6）或（-17,5）。

随机整数不必均匀分布，而必须全部可能。

该程序始终以99个错误开始。

您可以忽略“ 1个错误”的语法错误。

错误数量为0或负数时，程序应停止并打印

代码中的0个错误

错误绝不能出现负数。结局应该像

代码中的Y个错误

代码中的Y个错误

取下并修补

代码中的0个错误

（空行）

代码中的0个错误

尾随新行是可以接受的。

• 您的代码可以是完整程序或函数。
• 没有输入。
• 输出应为stdout或返回。
• 只要STDOUT包含必需的文本，日志/ STDERR中的警告/错误就可以。有关更多信息，请参见此处。

这是代码高尔夫球，因此以字节为单位的最短代码获胜。

示例输出

每次粘贴-11错误时粘贴的bin示例输出

[R ，182个 140 138 135字节

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="")

在线尝试！

尽管R在随机数生成方面相当出色，但在字符串和打印方面却很糟糕。 JayCe发现了大约十亿字节，并继续寻找新的打高尔夫球方式！

Java 8，161160字节

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个字节感谢@JonathanAllan。

在线尝试。

说明：

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字节

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

在线尝试！

“代码中的错误”部分已保存到$b以后使用。设置$a为99，进入for循环$a。首先，我们创建一个包含两个字符串的数组," "*2，该字符串为"X bugs in the code"。

接下来就是字符串"Take one down and patch it around"。然后我们从范围内$a选择一个Random整数来递增[-16,4]。之后，我们$a使用if将其钳位为最小零if($a-lt0){$a=0}。然后是字符串"Y bugs in the code"。

最后，在循环完成之后，我们将字符串放入"0 bugs in the code"管道中。所有这些字符串都是从管道中收集的，并且隐式Write-Output为我们免费提供了它们之间的换行符。

使用for循环而不是循环保存了两个字节while。
通过移至$b其自己的节来节省两个字节。
多亏了Adrian Blackburn，节省了两个字节。

JavaScript（Node.js），127字节

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

在线尝试！

说明：

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

感谢@tsh提供递归和实现的想法（节省了一些字节）

欢迎进一步打高尔夫球。

05AB1E，59个字节

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

在线尝试！

Python 2，151字节

尼斯把戏j=i+max(-i,randint(-16,4))由乔景，允许利用分布不均

由于助记符，节省了几个字节

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

在线尝试！

木炭，81字节

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

在线尝试！链接是详细版本的代码。说明：

≔⁹⁹θ

从代码中的99个错误开始。

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

保存压缩的字符串“代码中的％d错误” \ n。

Ｗ›θ⁰«

重复进行，同时要保留大量的错误。

ײ﹪ζθ

打印两次代码中的错误数。

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

打印“放下并修补”。

≧⁺⁻⁴‽²¹θ

在-17（不含）到4（含）之间添加随机数量的错误。

﹪ζ×θ›θ⁰

打印剩余的错误数；如果为负，则显示0。

¶

在经文之间留空行。

»﹪ζ⁰

在最后一节经文之后，再次在代码中打印0个错误。

JavaScript中，189个 176 168 162字节

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)}

在线尝试！

感谢Muhammad Salman所缺少的console.log替代产品，并感谢Oliver的x测试改进

感谢l4m2打高尔夫球这8字节

Python 3中，156个 138字节

由于乔纳森的Python的2答案的id伎俩

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)

在线尝试！

说明：

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

八度，149148字节

通过将randi(21)和更改%i为21*rand和保存一个字节%.f。%.f确保输出为带有零小数（即和整数）的浮点数。

插入一堆换行符，而不是逗号和分号，以简化可读性。感觉错了，但不超过一线。

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)

在线尝试！

说明：

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.

使用p((x+=21*rand-17)*(x>0)而不是max保存一个字节，但是最后一行输出-0 bugs ...而不是0 bugs。它可与一起使用randi(21)-17，但长度与上述相同。在线尝试！

COBOL（GnuCOBOL），317个 294 279 270字节

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"

在线尝试！

不打高尔夫球

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

注意：最后一句话仍然被打印，因为COBOL执行整个程序，并且在perform until循环之后它“掉进”标签a并执行其语句。此行为类似于switch case没有break。

PS：不能完全按照要求显示数字，但是COBOL并不擅长将数字自动转换为漂亮的文本表示形式。

VBA：212个 163字节

此解决方案基于Chronocidal昨天发布的解决方案。这是我的第一篇文章，我没有足够的声誉来评论他的文章。

此修订包含两个增强功能。

1. 使用While/Wend而不是For/Next保存一些字符。
2. 调用以单个字符命名的Sub比支持它GoSub的Exit Suband和Returnline 更短。

编辑：
3.删除空格和字符VBA编辑器会自动添加回去见提示在VBA高尔夫
由@EricF 4.添加的建议，然后看到他贴斌算法是更小的，所以我代替我的算法与他和去除空格。关键的变化是附加vbLF到输出字符串，因此Debug.Print不必经常调用。对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

这是一个有趣的挑战。如果您知道用于VB6 / VBScript / VBA 的在线解释器（如TIO），请发表评论。

如果要测试此代码并安装Microsoft Excel，Word，Access或Outlook（仅Windows），请按Alt + F11打开VBA IDE。插入一个新的代码模块（Alt + I，M）并清除Option Explicit。然后粘贴代码并按F5键运行它。结果应显示在“立即窗口”中（如果看不到，请按Ctrl + G）。

乳胶，368个 304 293 287 245 240字节

虽然在字节方面与其他程序相比并没有真正的竞争力，但我只是想看看如何在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}

更具可读性：

\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}

改进（每次编辑）：

1. “代码中的x个错误”现在是一个函数，而不是4行
2. 将\if条款重写\repeat为\else
3. 显然\value{b}=x适用于初始化，但不在循环中（而不是\setcounter{b}{x}）
4. 显然\relax应该用于第3点，但是也可以通过插入空格来实现。删除了\else使用的TeX命令而不是LaTeX，因为它们更短，\'并由代替~。
5. 由于某些原因，一些代码不需要放松。

C， 169165 字节

感谢@ceilingcat节省了四个字节！

*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);}

在线尝试！

SAS，210字节

%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

取消高尔夫：

%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

如果允许在日志中显示警告，则可以节省一些字节（输入 &a&b宏放入宏变量中，但会生成初始警告）。

PHP，126字节

使用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
";

阿巴普，295字节

...因为为什么不这样！

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.

与其他语言相比，它当然没有竞争力，但是我什至设法将它的大小从最初编写的330个字节减少到最小，因此我将其视为个人的胜利。

由于ABAP不允许行数超过255个字符，因此我不得不用换行符代替空格。在Windows上，由于CRLF，此大小最初增加到296字节，但仅在其中LF的情况下运行良好。ABAP当然需要很多空间，所以这没什么大不了的。

WRITE只是将文本转储到GUI，所以我想那有点像stdout吗？我可能可以通过使用结构或表在此处节省一些字节，但是由于SAP如何处理混合结构（包含字符和数字），所以我想象的方法仅适用于非Unicode系统...我个人认为不行，尽管可以同时访问两者。

我想在我们的系统中可以找到唯一的随机数功能模块，我想可能会有一个名称或参数较短的模块。不知道！

或多或少可读的代码，包括以下注释：

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.

感谢您的挑战！
对我的老板：请不要解雇我，我只是在自学！

干净，245个 234字节

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"

在线尝试！

C＃，184个 181字节

我的第一个Code Golf答案！

（基于@Kevin Cruijssen的Java答案）

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;};

在线尝试！

C（GCC） ，141个 137字节

我使用了预处理器宏来实现更大的正义（警告：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);}

在线尝试！

T-SQL，188个字节

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允许在字符串文字内返回，因此很有帮助。

CONCAT()隐式转换为文本，因此我不必担心CAST或CONVERT。

JavaScript，138个字节

_=>(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字节

来自我兄弟

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字节

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

在线尝试

先前版本：94个字节

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

果冻，61 字节

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

一个尼拉度链接，它也可以作为完整程序使用。

在线尝试！（执行完成后刷新输出，但逐段打印）

怎么样？

;“,Ȥ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个字节

$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字节

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} 添加了缺少的内容rnd()*

注意：
用于GoSub打印重复的行，因为它比将行分配给变量并对其进行Debug.Print输入要短一些。
Debug.Print不带任何参数的行将显示一个空行（不需要Null或空字符串）。WorksheetFunction.Max行会太长，因此我使用了“如果小于”来防止出现负数。

带有缩进和注释

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字节

-1感谢Jo King（重新排列以便使用逻辑bugs-=min(bugs,randomNumber)而不是bugs=max(0,bugs-randomNumber)）。这样就可以通过除以零误差来强制退出，从而节省了另外6个字节！

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

在线尝试！

Ruby：149个字节

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

应该可以在几乎所有Ruby> = 1.8版本中使用

我认为可能可以进一步优化字符串，但总的来说，我对此感到非常满意-特别是组合分配/比较/中断语句以及可选方括号的滥用。

注意：输出在技术上有两个尾随换行符；如果需要说明，则增加4个字符。

Zsh，133字节

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

在线尝试！

这利用了一些zsh功能。

• 在替代环形式：while list; do list; done可写为while list {list}
• 如果格式说明符在 printf为数字，则将相应的参数作为算术表达式求值。所以：
  • 我们n免费获得价值，而无需使用$
  • n -= RANDOM % 21 - 4, n = n > 0 ? n : 0再次评价，而无需使用$((...))，$[...]或类似的。在>与?必须逃脱。
  • 最后的printf $b，将的空参数评估为0 %d。
• 默认情况下，参数扩展时的单词拆分功能处于关闭状态，因此我不必引用 $b任何地方。
  • 这允许我$b$b"Take..."代替来编写"$b${b}Take..."。

• 使用实际的换行符代替\n和for((n=99;n;))来节省一些字节n=99;while ((n))。