कोड में 99 बग

47

कोड में 99 बग

कंप्यूटर विज्ञान के लिए "दीवार पर 99 बोतल बीयर" का अनुकूलन जहां बोतलों के घटने के बजाय कीड़े बढ़ते हैं, अक्सर इंटरनेट के आसपास फिर से पोस्ट किया जाता है। उदाहरण यहाँ टी शर्ट ।

मुझे लगता है कि विभिन्न प्रकार की भाषाओं में संभावित पुनरावृत्ति और यादृच्छिक संख्या पीढ़ी को देखना दिलचस्प होगा और इसे करने के लिए सबसे प्रभावी तरीके खोजने होंगे।

बियर की 99 बोतलों के साथ करने के लिए कुछ अन्य चुनौतियां हैं, लेकिन बढ़ती संख्या और घटती संख्या के लिए कोई भी नहीं लगता है!

चुनौती

आपके प्रोग्राम या फ़ंक्शन को कोई इनपुट नहीं लेना चाहिए और फिर प्रिंट करना चाहिए

कोड में 99 बग

कोड में 99 बग

एक नीचे ले जाओ और इसे चारों ओर पैच

कोड में एक्स बग्स

(खाली पंक्ति)

जहां X पिछले पूर्णांक शून्य से 1 प्लस है [[-15,5] श्रेणी में एक यादृच्छिक पूर्णांक।
आप रैंडम पूर्णांक में माइनस 1 को मर्ज कर सकते हैं, इसलिए सीमा [-16,4] की अनुमति देता है।
रंग अनन्य हो सकते हैं, इसलिए माइनस एक प्लस (-16,6) या (-17,5)।

यादृच्छिक पूर्णांकों को समान रूप से वितरित करने की आवश्यकता नहीं होती है, बस उन्हें सभी संभव होना चाहिए।

कार्यक्रम हमेशा 99 बग के साथ शुरू होता है।

आप "1 बग" की व्याकरणिक त्रुटि को अनदेखा कर सकते हैं।

बग्स की संख्या 0 या नकारात्मक होने और प्रिंट होने पर प्रोग्राम बंद हो जाना चाहिए

कोड में 0 बग

कभी भी बग की नकारात्मक संख्या नहीं होनी चाहिए। अंत जैसा दिखना चाहिए

Y कोड में कीड़े

Y कोड में कीड़े

एक नीचे ले जाओ और इसे चारों ओर पैच

कोड में 0 बग

(खाली पंक्ति)

कोड में 0 बग

एक अनुगामी नई रेखा स्वीकार्य है।

  • आपका कोड एक पूर्ण कार्यक्रम या फ़ंक्शन हो सकता है।
  • कोई इनपुट नहीं है।
  • आउटपुट को स्टडआउट या लौटाया जाना चाहिए।
  • लॉग / STDERR में चेतावनी / त्रुटियां तब तक ठीक हैं जब तक STDOUT में आवश्यक पाठ है। अधिक जानकारी के लिए यहां देखें ।

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है।

उदाहरण आउटपुट

हर बार -11 बग्स के लिए बिन उदाहरण के आउटपुट में हेराफेरी करें

code-golf  random 
— सैम डीन
स्रोत
1
संबंधित: 1 2 (अंतर: इस चुनौती में आउटपुट मनमाने ढंग से लंबा हो सकता है)।
— user202729
16
एक अधिक यथार्थवादी परिदृश्य होगा यदि यादृच्छिक संख्या का संकेत फ़्लिप किया गया था!
— स्टिव ग्रिफिन
9
मैं निराश हूं, कि आवश्यकताओं में यह शामिल नहीं है कि प्रोग्राम में बग होने के बाद एक नकारात्मक संख्या का सामना करना पड़ता है, जैसे दुर्घटनाग्रस्त होना, अधिकतम इंट या इसी तरह बहना;)।
— allo
3
"यादृच्छिक पूर्णांकों को समान रूप से वितरित करने की आवश्यकता नहीं होती है, बस उन्हें सभी संभव होना चाहिए।" मुझे याद दिलाया xkcd.com/221
— इवो ​​बेकर्स
2
यह शर्म की बात है 99 की कोई यादृच्छिक संख्या पीढ़ी नहीं है।
— जोनाथन एलन

जवाबों:

18

आर , 182 140 138 138 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यादृच्छिक संख्या पीढ़ी में यथोचित रूप से अच्छा होने के बावजूद, आर स्ट्रिंग्स और प्रिंटिंग में भयानक है। JayCe ने एक बिलियन बाइट्स के बारे में पाया, और इसे गोल्फ के नए तरीके खोजना जारी रखा!

— ग्यूसेप
स्रोत
1
JayCe ने उन सभी बाइट्स को कहां पाया? क्या यह सिर्फ घटाव था या JayCe सक्रिय रूप से उनकी तलाश कर रहा था?
— स्टीवी ग्रिफिन
2
— JayCe
— जेसीई
+5आप एक और 2 बाइट्स लागत नहीं है ? सिर्फ क्यों नहीं sample(26,6))?
— theforestecologist
2
@forestecologist पीपीसीजी में आपका स्वागत है! मेरा सुझाव है कि आप प्रश्न पर एक करीब से नज़र डालें ... सामने एक ऋण चिह्न हैsample
— JayCe
11

जावा 8, 161 160 बाइट्स

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
— केविन क्रूज़सेन
स्रोत
लगता है कि आप rकिसी चीज के लिए उपयोग नहीं कर रहे हैं ?
— OOBalance
1
हटाना ,rअभी भी काम करता है: इसे ऑनलाइन आज़माएं!
— कामिल दकरी
@Oobalance उफ़ .. मुझे यकीन नहीं है कि मुझे वहां क्यों मिला ..>>> ध्यान देने के लिए धन्यवाद।
— केविन क्रूज़सेन
1
i - = ... + 5 एक बचाता है (हालांकि मुझे लगता है कि रेंज [-16 4] होनी चाहिए [-15,5])
— जोनाथन एलन
1
@Oobalance हाँ r का उपयोग नहीं किया गया है, क्योंकि वह जावा ;-) का उपयोग कर रहा है
— आनंद रॉकज़
10

पावरशेल , 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($a-lt0){$a=0}। फिर तार "Y bugs in the code"।

अंत में, लूप समाप्त होने के बाद, हम "0 bugs in the code"पाइप लाइन पर स्ट्रिंग लगाते हैं। उन सभी तारों को पाइप लाइन से इकट्ठा किया जाता है, और एक निहितार्थ Write-Outputहमें मुफ्त में उनके बीच नई शुरुआत देता है।

एक forलूप के बजाय एक लूप का उपयोग करके दो बाइट्स सहेजे गए while। अपने स्वयं के अनुभाग पर
जाकर दो बाइट्स सहेजे $b।
एड्रियन ब्लैकबर्न के लिए धन्यवाद दो बाइट्स सहेजे गए।

— AdmBorkBork
स्रोत
आप $ a = (0, $ a) [$ a-gt0] को बदल सकते हैं; अगर ($ a-lt0) {$ a = 0} बाइट्स के एक जोड़े के लिए
— एड्रियन
@ AdrianBlackburn धन्यवाद!
— AdmBorkBork
9

जावास्क्रिप्ट (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 को धन्यवाद (कुछ बाइट्स को बचाया)

इसे आगे बढ़ाने के लिए किसी भी सुझाव का स्वागत है।

— मुहम्मद सलमान
स्रोत
— TSH
1
क्यों 0+हटाया गया ? यह आवश्यक उत्पादन प्रतीत होता है।
— TSH
@tsh: यह है? मैंने वह हिस्सा नहीं पढ़ा।
— मुहम्मद सलमान
6

पायथन 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

इसे ऑनलाइन आज़माएं!

— मृत पोसुम
स्रोत
1
आप एक बाइट का उपयोग करके बचा सकते हैं j=max(0,i+randint(-16,4))।
— मेमेनिक
इसके अलावा, यह है 'में कीड़े कोड'।
— मेमनोनिक
Wiil की तुलना करने के लिए 0 का उपयोग करना सभी संख्याओं को संभव नहीं बनाता है। कुछ भी नहीं 'के लिए धन्यवाद: D
— मृत Possum
मेरे जवाब के रूप में एक ही चाल, 151 बाइट्स
— जो किंग
वे वैसे भी संभव नहीं हैं। आपको नीचे जाने की अनुमति नहीं है 0.
— Mnemonic
6

चारकोल , 81 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁹⁹θ

कोड में 99 बग से शुरू करें।

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

कोड \ n "" में संकुचित स्ट्रिंग "% d बग्स" को सहेजें।

Ｗ›θ⁰«

बाकी कीड़ों की एक सकारात्मक संख्या होने पर दोहराएं।

ײ﹪ζθ

कोड में दो बार बग्स की संख्या प्रिंट करें।

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

"एक नीचे ले लो और इसे चारों ओर पैच"।

≧⁺⁻⁴‽²¹θ

-17 (अनन्य) और 4 (समावेशी) के बीच बग्स की एक यादृच्छिक संख्या जोड़ें।

﹪ζ×θ›θ⁰

शेष बग की संख्या प्रिंट करें, या यदि नकारात्मक हो तो 0।

छंदों के बीच एक रिक्त रेखा छोड़ दें।

»﹪ζ⁰

अंतिम कविता के बाद, कोड में 0 बग को फिर से प्रिंट करें।

— नील
स्रोत
उस कोड को "कोड में 0 बग" दोहराए जाने की आवश्यकता है!
— सैम डीन
1
@SamDean क्षमा करें, मैंने इसे अनदेखा कर दिया, निश्चित किया।
— नील
6

जावास्क्रिप्ट, 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)}

इसे ऑनलाइन आज़माएं!

लापता प्रतिस्थापन के लिए मुहम्मद सलमान के लिए धन्यवाद console.log, और एक्स परीक्षण में सुधार के लिए ओलिवर के लिए

8 बाइट्स द्वारा इसे गोल्फ के लिए l4m2 के लिए धन्यवाद

— यादृच्छिक आदमी
स्रोत
मैं कोई नोड विशेषज्ञ नहीं हूं, लेकिन मेरा मानना ​​है कि "कार्यक्रम को रोकना चाहिए जब बग की संख्या 0 या नकारात्मक है" का मतलब है कि आपको x<=0?console.log("\n"+0+a):f(x)अंत में आवश्यकता है ।
— NoOneIsHere
1
ठीक है माफ़ कर दो। एक और बात: अगर आपको किसी गुमनाम फंक्शन में
— दुबारा आने की
1
पिछले "कंसोल.लॉग" को "सी" से बदला नहीं जा सकता है?
— सैम डीन
1
इसके अलावा @NoOneIsHere सही है। आपको उस fघोषणा की आवश्यकता है । इसे ठीक करने के लिए अपडेट किए जाने तक नीचे वोट किया गया। (इसके अलावा मेरे लिंक को भी अपडेट चाहिए)
— मुहम्मद सलमान
2
जिस बिंदु को मैं यहां बनाने की कोशिश कर रहा हूं, वह यह है कि आपका कोड काम नहीं करता है यदि फ़ंक्शन को नहीं बुलाया जाता है f, जिसे आप मान नहीं सकते हैं।
— NoOneIsHere
6

पायथन 3 , 156 138 बाइट्स

चाल के लिए जोनाथन के पायथन 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
— मजाक कर रहा है
स्रोत
5

ऑक्टेव , 149 148 बाइट्स

बदलकर एक बाइट सहेजा 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, लेकिन फिर यह ऊपर की लंबाई के समान है। इसे ऑनलाइन आज़माएं!

— स्टीवी ग्रिफिन
स्रोत
5

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"

इसे ऑनलाइन आज़माएं!

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

नोट: अंतिम वाक्य अभी भी मुद्रित है, क्योंकि COBOL पूरे कार्यक्रम को निष्पादित करता है, और perform untilलूप के बाद लेबल को "फॉल्स-थ्रू" करता है , अपने बयानों को निष्पादित करता है। यह व्यवहार switch caseबिना किसी के समान है break।

पुनश्च: संख्याओं को आवश्यक रूप से प्रदर्शित नहीं किया जाता है, लेकिन COBOL एक बहुत ही शाब्दिक प्रतिनिधित्व के लिए ऑटो-कनवर्टिंग संख्याओं में अच्छा नहीं है।

— एम सी सम्राट
स्रोत
1
नमस्ते। PPCG में आपका स्वागत है।
— मुहम्मद सलमान
मुझे लगता है कि माइनस 4 प्लस 4 होना चाहिए। मैं अनुमान लगा रहा हूं कि आप (i- (रैंड -4) == (आई-रैंड + 4) के लिए गए थे। लेकिन कोई कोष्ठक नहीं है, इसलिए संकेत को बदलने की जरूरत है। संकेत भी कर सकते हैं। संख्याओं को हटा दिया जाए या क्या यह भाषा की विशेषता है? लेकिन एक गैर-सोने की अनुकूल भाषा के साथ अच्छा काम!
— सैम डीन
1
@SamDean धन्यवाद! मैंने वह गलती ठीक कर दी। मुझे स्वीकार करना पड़ा कि वास्तविक यादृच्छिक गणना केविन क्रूज़सेन के जवाब से प्रेरित थी । लेकिन वह एक कंपाउंड असाइनमेंट ऑपरेटर ( -=इन i-=Math.random()*21-4) का उपयोग करता है , जो पूरे दाहिने ऑपरेंड के आसपास कोष्ठक का अर्थ है। मैं उन्हें स्पष्ट करना भूल गया, लेकिन यह अब तय हो गया है, मुझे लगता है।
— एमसी सम्राट
@ मम्मे मुझे अब अच्छे लगते हैं!
— सैम डीन
क्या आप +4 का उपयोग नहीं कर सकते हैं और कोष्ठक सहेज सकते हैं?
— राजनागुल
4

VBA: 212 163 बाइट्स

यह समाधान क्रोनोसाइडल द्वारा कल पोस्ट किए गए एक पर आधारित है। यह मेरी पहली पोस्ट है और मेरे पास उनकी पोस्ट पर टिप्पणी करने के लिए पर्याप्त प्रतिष्ठा नहीं है।

इस संशोधन में दो संवर्द्धन शामिल हैं।

  1. का उपयोग While/Wendकरने के बजाय For/Nextकुछ वर्ण बचाता है।
  2. एक भी चरित्र के साथ नाम के एक उप कॉलिंग से कम है GoSubऔर Exit Subऔर Returnलाइनों इसे समर्थन की जरूरत है।

संपादित करें:
3. हटाए गए व्हाट्सएप और वर्णों को VBA संपादक स्वचालित रूप से वापस जोड़ देगा। VBA में गोल्फिंग के लिए टिप्स देखें।
@EricF द्वारा जोड़े गए सुझाव, फिर उसका पेस्ट बिन एल्गोरिथ्म भी छोटा था इसलिए मैंने अपने एल्गोरिथ्म को उसके साथ हटा दिया और हटा दिया। खाली स्थान के। vbLFआउटपुट स्ट्रिंग में एक महत्वपूर्ण बदलाव था, इसलिए Debug.Printइसे अक्सर कहा नहीं जाता था। कुडोस से एरिकएफ ।

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) है, तो VBA IDE खोलने के लिए Alt + F11 दबाएँ। एक नया कोड मॉड्यूल (Alt + I, M) डालें और साफ़ करें Option Explicit। फिर कोड में पेस्ट करें और इसे चलाने के लिए F5 दबाएं। परिणाम तत्काल विंडो में दिखाई देने चाहिए (यदि आप इसे नहीं देखते हैं तो Ctrl + G दबाएं)।

— बेन
स्रोत
4
साइट पर आपका स्वागत है!
— गेहूं जादूगर
1
आप इसे नीचे 197 अक्षरों तक अगर आप, तार गठबंधन का उपयोग प्राप्त कर सकते हैं cके बजाय c>0अपने जबकि शर्त के रूप में, और प्रयोग c=Iif(c<0,0,c)के बजाय If c<0 [...]: pastebin.com/nFGtGqdE
— ErikF
4

LaTeX , 368 304 293 287 245 240 बाइट्स

जबकि बाइट्स के संदर्भ में अन्य कार्यक्रमों की तुलना में वास्तव में प्रतिस्पर्धी नहीं है, मैं सिर्फ यह देखना चाहता था कि लाटेक्स में यह कैसे करना है।

\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. कुछ कोड को किसी कारण से आराम करने की आवश्यकता नहीं थी।
— साइमन कलेवर
स्रोत
1
PPCG में आपका स्वागत है।
— मुहम्मद सलमान
PPCG में आपका स्वागत है! मैंने आपका कोड नहीं चलाया है, लेकिन क्या इसके \ifnum\value{b}<1बजाय ऐसा नहीं होना चाहिए <0?
— JayCe
@ जय: यह वास्तव में कोई बात नहीं है, एक बार बी 0 है यह वैसे भी लूप से बच जाता है। यह कम सहज हो सकता है कि जब b 0 हो तो दूसरा मामला वास्तव में मुद्रित हो, लेकिन प्रभावी रूप से मेरे विचार में कोई अंतर नहीं है।
— शमौन कलेवर
@JayCe ने कोड को छोटा कर दिया, अब इससे कोई फर्क नहीं पड़ता;)
— साइमन कलेवर
4

सी,  169  165 बाइट्स

चार बाइट बचाने के लिए @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);}

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत
3

एसएएस, 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

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

यदि लॉग में चेतावनी दी गई है तो कुछ बाइट्स बचा सकते हैं ( मैक्रो चर &aमें डालें &b, लेकिन यह एक प्रारंभिक चेतावनी उत्पन्न करता है)।

— जो
स्रोत
कुछ अन्य लोगों को चेतावनी है तो मैं उनके साथ जाने की अनुमति दूंगा।
— सैम डीन
3

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 वर्णों से अधिक लंबी लाइनों की अनुमति नहीं देता है, इसलिए मुझे एक पंक्ति विराम के साथ एक स्थान बदलना पड़ा। विंडोज पर यह शुरुआत में CRLF के कारण आकार को 296 बाइट्स तक बढ़ाता था, लेकिन यह केवल LF के साथ वहाँ ठीक चलता है। हालांकि ABAP को कई स्थानों की आवश्यकता होती है, इसलिए यह कोई बड़ी बात नहीं है।

राइट बस जीयूआई पाठ को डंप करता है, इसलिए मुझे लगता है कि स्टडआउट की तरह है? मैं शायद एक संरचना या तालिका का उपयोग करके यहां कुछ बाइट्स बचा सकता था, लेकिन एसएपी मिश्रित संरचनाओं (चार्ट और संख्याओं से युक्त) को कैसे संभालता है, इसके बारे में मैंने जो कल्पना की थी वह केवल गैर-यूनिकोड सिस्टम पर काम करेगी ... जिसे मैं व्यक्तिगत रूप से एक नहीं मानता- दोनों तक पहुंच के बावजूद, जाओ।

यादृच्छिक संख्याओं के लिए फ़ंक्शन मॉड्यूल केवल एक ही है जो मुझे हमारे सिस्टम में मिल सकता है, मुझे लगता है कि एक छोटे नाम या मापदंडों के साथ एक हो सकता है। कोई जानकारी नहीं!

अधिक या कम पठनीय कोड, टिप्पणियाँ शामिल हैं:

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.

चुनौती के लिए धन्यवाद!
मेरे बॉस के लिए: कृपया मुझे फायर मत करो, मैं सिर्फ खुद को शिक्षित कर रहा हूँ!

— Maz
स्रोत
3

क्लीन , 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"

इसे ऑनलाइन आज़माएं!

— Οurous
स्रोत
किसी भी मौका आप शुरू और अंत में उद्धरण हटा सकते हैं?
— सैम डीन
1
@SamDean ओह, यह सिर्फ एक संकलक विकल्प है जिसके बारे में मैं भूल गया था। मैं उसे फेंक
— दूंगा
3

सी #, 184 181 बाइट्स

मेरा पहला कोड गोल्फ जवाब!

( @ केविन क्रूज़सेन से जावा जवाब पर आधारित )

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

इसे ऑनलाइन आज़माएं!

— बेन नोबल
स्रोत
1
PPCG :) में आपका स्वागत है
— झबरा
3

सी (जीसीसी) , 141 137 बाइट्स

मैंने महान न्याय के लिए प्रीप्रोसेसर मैक्रोज़ का इस्तेमाल किया (चेतावनी: टीवी ट्रॉप्स)

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

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत
2

टी-एसक्यूएल, 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।

— BradC
स्रोत
2

जावास्क्रिप्ट, 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)

कोड स्निपेट दिखाएं

— darrylyeo
स्रोत
2

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$
— ErikF
स्रोत
2

जेली , 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
— जोनाथन एलन
स्रोत
2

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बिना किसी तर्क के एक खाली लाइन को प्रिंट करता है (शून्य या रिक्त स्ट्रिंग की कोई आवश्यकता नहीं है) एक 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
— Chronocidal
स्रोत
1
यादृच्छिक संख्या करने के लिए यह एक बहुत ही कुशल तरीका है!
— सैम डीन
@SamDean यकीन नहीं है कि मैं कैसे इसमें शामिल करना भूल गया rnd() * - मुझे लगता है कि अगर मैं कम वर्णों में व्यस्त था Dim c%(यानी "c is a Integer") और Int()
— ड्रॉपऑन
कोई चिंता नहीं! एक VBA उत्तर देखकर अच्छा लगा क्योंकि मैंने वर्षों में इसका उपयोग नहीं किया है!
— सैम डीन
2

पायथन 2 ,  138 134 133 131  127 बाइट्स

-1 जो किंग के लिए धन्यवाद ( 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

इसे ऑनलाइन आज़माएं!

— जोनाथन एलन
स्रोत
मुझे पता है कि मुझे बिल्कुल भी ट्यूल बनाने की आवश्यकता नहीं है।
— जोनाथन एलन
— जो किंग
@JoKing धन्यवाद! (मैं वास्तव में देखा जाना चाहिए कि चूंकि यह अधिक है जैसे मैं अपने जेली उत्तर में करता हूं।)
— जोनाथन एलन
2
@JoKing ... जिसका अर्थ है कि हम शून्य त्रुटि से एक डिवीजन को छोड़ने के लिए मजबूर कर सकते हैं --two-- छह और अधिक :)
— जोनाथन एलन
2

रूबी: 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

रूबी> = 1.8 के किसी भी संस्करण में काम करना चाहिए

मुझे लगता है कि स्ट्रिंग्स को थोड़ा और अधिक अनुकूलित करना संभव हो सकता है, लेकिन सामान्य तौर पर मैं इससे बहुत खुश हूं - विशेष रूप से कॉम्बो असाइनमेंट / तुलना / ब्रेक स्टेटमेंट और वैकल्पिक ब्रैकेट्स का दुरुपयोग।

नोट: आउटपुट तकनीकी रूप से दो अनुगामी न्यूलाइन्स है; अगर उस हिसाब की जरूरत है तो यह 4 वर्णों तक बढ़ जाता है।

— DaveMongoose
स्रोत
नमस्कार, और PPCG में आपका स्वागत है! हम नई अनुगामी गणना करते हैं, लेकिन यदि यह लिनक्स पर काम करती है तो आप केवल \n(नहीं \r) की गिनती कर सकते हैं ।
— NoOneIsHere
@NoOneIsHere धन्यवाद :) मैंने स्पष्ट करने के लिए अपना उत्तर अपडेट कर दिया है - मैं आउटपुट पर newlines का उल्लेख कर रहा था क्योंकि प्रश्न निर्दिष्ट करता है कि एक स्वीकार्य है, लेकिन मुझे दो के बारे में निश्चित नहीं था।
— डेवमंगोज
समझा। मुझे लगता है कि यह ठीक है
— NoOneIsHere
2

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..."।
  • के बजाय वास्तविक newlines का उपयोग करके कुछ बाइट्स सहेजे गए \n, और for((n=99;n;))इसके बजाय n=99;while ((n))।
— muru
स्रोत
मुझे लगता है कि यह -4 होना चाहिए। "- =" इसके यौगिक जैसा दिखता है इसलिए यह पहले +4 करता है फिर इसे सभी घटाता है।
— सैम डीन
@SamDean उफ़, सही किया गया।
— मुरु
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.