코드의 99 버그

컴퓨터 과학을위한 "벽에 맥주 99 병 병"의 적응은 병을 줄이는 대신 버그가 증가하는 경우가 종종 인터넷 주위에 다시 게시됩니다. 티셔츠 예 .

다양한 언어에서 재귀와 난수가 생성되는 것을보고 가장 효율적인 방법을 찾는 것이 흥미로울 것이라고 생각합니다.

99 병의 맥주와 관련하여 다른 몇 가지 도전 과제가 있지만 증가하고 감소하는 숫자는 없습니다!

도전

프로그램이나 기능을 입력하지 말고 인쇄하십시오

코드의 99 버그

코드의 99 버그

하나를 가져 와서 패치하십시오

코드의 X 버그

(빈 줄)

여기서 X는 이전 정수에서 1을 뺀 값에 [-15,5] 범위의 임의의 정수를 더한 값입니다.
빼기 1을 임의의 정수로 병합하여 [-16,4] 범위를 허용 할 수 있습니다.
범위는 배타적 일 수 있으므로 마이너스 1 더하기 (-16,6) 또는 (-17,5)입니다.

임의의 정수는 균등하게 분배 될 필요는없고 모두 가능해야합니다.

이 프로그램은 항상 99 개의 버그로 시작합니다.

"1 버그"의 문법 오류는 무시해도됩니다.

버그 수가 0이거나 음수이면 프로그램이 중지되고 인쇄됩니다.

코드의 버그 0 개

음수의 버그가 없어야합니다. 결말은 다음과 같아야합니다

코드의 Y 버그

코드의 Y 버그

하나를 가져 와서 패치하십시오

코드의 버그 0 개

(빈 줄)

코드의 버그 0 개

후행 줄 바꿈이 허용됩니다.

• 코드는 전체 프로그램 또는 함수일 수 있습니다.
• 입력이 없습니다.
• 출력은 stdout이거나 리턴되어야합니다.
• STDOUT에 필요한 텍스트가있는 한 로그 / STDERR의 경고 / 오류는 정상입니다. 자세한 내용은 여기 를 참조 하십시오 .

이것은 코드 골프이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

출력 예

매번 -11 개의 버그에 대해 리깅 된 빈 예제 출력

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는 약 10 억 바이트를 발견했으며이를 계속해서 골프를 즐길 수있는 새로운 방법을 계속 찾고 있습니다!

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

@JonathanAllan 덕분에 -1 바이트 .

온라인으로 사용해보십시오.

설명:

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선택하여 증가시킵니다 . 그런 다음 if를 사용하여 최소 0이되도록 고정 합니다 . 그런 다음 문자열 입니다.Random[-16,4]$aif($a-lt0){$a=0}"Y bugs in the code"

마지막으로 루프가 끝나면 "0 bugs in the code"파이프 라인에 문자열을 넣습니다. 이러한 모든 문자열은 파이프 라인에서 수집되며 암시 적으로 Write-Output줄 사이에 줄 바꿈이 무료로 제공됩니다.

for루프 대신 루프를 사용하여 2 바이트를 저장했습니다 while. 자체 섹션
으로 이동 $b하여 2 바이트를 절약 했습니다.
Adrian Blackburn 덕분에 2 바이트를 절약했습니다.

자바 스크립트 (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Š»

온라인으로 사용해보십시오!

파이썬 2 , 151 바이트

j=i+max(-i,randint(-16,4))허용되지 않는 분포를 이용하여 Jo King의 멋진 트릭

니모닉 덕분에 몇 바이트 절약

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 bugs in the code \ n"을 저장하십시오.

Ｗ›θ⁰«

양의 버그가 남아있는 동안 반복하십시오.

ײ﹪ζθ

코드의 버그 수를 두 번 인쇄하십시오.

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

"하나를 내려서 패치하십시오"를 인쇄하십시오.

≧⁺⁻⁴‽²¹θ

-17 (독점)과 4 (포함) 사이에 임의의 수의 버그를 추가하십시오.

﹪ζ×θ›θ⁰

남아있는 버그 수를 인쇄하거나 음수이면 0을 인쇄하십시오.

¶

구절 사이에 빈 줄을 두십시오.

»﹪ζ⁰

마지막 구절이 끝나면 코드에 0 개의 버그를 다시 인쇄하십시오.

자바 스크립트, 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 Salmanconsole.log 과 x 테스트 개선에 대한 Oliver 에게 감사합니다.

8 바이트 씩 골프 를 해주신 l4m2 에게 감사 합니다

파이썬 3 , 156138 바이트

트릭에 대한 Jonathan의 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 casewithout 와 비슷합니다 break.

추신 : 숫자는 필요한대로 정확하게 표시되지 않지만 COBOL은 숫자를 예쁜 텍스트 표현으로 자동 변환하는 데 적합하지 않습니다.

VBA : 212 163 바이트

이 솔루션은 어제 Chronocidal이 게시 한 솔루션을 기반으로합니다. 이것은 나의 첫 번째 게시물이며 그의 게시물에 대해 언급 할만한 평판이 충분하지 않습니다.

이 개정판에는 두 가지 개선 사항이 포함되어 있습니다.

1. While/Wend대신에를 사용 For/Next하면 몇 개의 문자 가 저장됩니다.
2. 하나의 문자로라는 이름의 하위를 호출하면보다 짧은 GoSub과 Exit Sub와 Return라인을 지원하는 데 필요한.

편집 :
3. VBA 편집기가 자동으로 다시 추가 할 공백과 문자를 제거했습니다. VBA에서 골프 팁 4를 참조하십시오.
@EricF의 제안을 추가 한 다음 그의 붙여 넣기 알고리즘이 더 작아서 알고리즘을 그의 것으로 대체하고 제거했습니다. 공백. 주요 변경 사항은 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에 대한 절을 \repeatA와\else
3. 분명히 \value{b}=x(대신 루프에 초기화 작동하지만 \setcounter{b}{x})
4. 분명히 \relax포인트 3에 사용해야하지만 공백을 삽입하여 얻을 수도 있습니다. 를 제거하고 \elseLaTeX 대신 TeX 명령을 사용하고이 명령이 더 짧아서로 대체 \'되었습니다 ~.
5. 어떤 이유로 일부 코드를 완화 할 필요가 없었습니다.

C,  169165  바이트

4 바이트를 절약 한 @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
";

ABAP , 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가 문자와 숫자를 포함하여 혼합 구조를 처리하는 방식으로 인해 유니 코드가 아닌 시스템에서만 작동한다고 상상했습니다. 둘 다에 액세스 할 수 있음에도 불구하고 이동하십시오.

난수에 대한 함수 모듈은 우리 시스템에서 찾을 수있는 유일한 것입니다. 이름이나 매개 변수가 더 짧은 것이 있다고 가정합니다. 몰라!

다소 읽기 쉬운 코드, 주석 포함 :

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.

도전 해 주셔서 감사합니다!
상사에게 : 제발 날 해고하지 말고, 나는 단지 나 자신을 교육하고 있습니다!

클린 , 245234 바이트

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 #, 184181 바이트

내 첫 번째 코드 골프 답변!

( @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.

자바 스크립트, 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

펄, 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

{편집} 누락 된 항목 추가rnd()*

참고 : 변수에 선을 할당하고 꽂는 것보다 약간 짧기 때문에 3 중 선을 인쇄하는 데
사용 합니다. 인수가 없으면 빈 줄이 인쇄됩니다 (Null 또는 빈 문자열이 필요 없음) 줄이 너무 길어서 음수를 방지하기 위해 "보다 작은 경우"를 사용했습니다. GoSubDebug.Print
Debug.PrintWorksheetFunction.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

파이썬 2 ,  138134133131127  바이트

-1 Jo King에게 감사합니다 ( bugs-=min(bugs,randomNumber)대신 논리를 사용하도록 재정렬 bugs=max(0,bugs-randomNumber)). 이것은 0으로 나누기를 사용하여 강제 종료하여 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

온라인으로 사용해보십시오!

루비 : 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}
• 형식 지정자가 in 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)).