एलिस और बॉब में झगड़ा होता है

Question

• ऐलिस (ए) और बॉब (बी) ने एक लड़ाई का फैसला किया।
• प्रत्येक लड़ाके के पास 10 स्वास्थ्य हैं।
• वे क्षति के लिए 6 पक्षीय मरने की बारी करते हैं।
• उस क्षति को उनके विरोधी के स्वास्थ्य से हटा दिया जाता है।
• अंत में या तो ऐलिस या बॉब, अपने दुश्मन को जीत लेंगे।

---

मुझे दिखाओ कि लड़ाई कैसे हुई। इन कोड को उन क्रियाओं के लिए आउटपुट करना, जो हुई हैं।

हमला

B a A    
^ Combatant
  ^ Action (attack)
    ^ Target

रोल

B r 4
^ Combatant
  ^ Action (roll)
    ^ Value

स्वास्थ्य में बदलाव

A h 6
^ Combatant
  ^ Attribute (health)
    ^ Value   

जीत

A w 
^ Combatant
  ^ Action (win)

---

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

A a B
A r 4
B h 6
B a A
B r 6
A h 4
A a B
A r 6
B h 0        
A w

---

ये नियम हैं:

• किसी भी भाषा में लिखें।
• मरने के एक ही रोल में संख्या 1, 2, 3, 4, 5, या 6 में से किसी एक में परिणाम का एक समान मौका होना चाहिए।
• ऐलिस हमेशा शुरू होती है (बॉब शिष्ट है, पुराने तरीके से)।
• प्रत्येक मोड़ के लिए एक कार्रवाई आउटपुट।
• आपको हमले, रोल, क्षति और कार्यों को जीतने की रिपोर्ट करनी चाहिए।
• मुकाबला ऊपरी मामला है, कार्रवाई कम मामला है।
• यह लगातार एक ही परिणाम का उत्पादन नहीं करना चाहिए।
• आउटपुट लड़ाके, कार्रवाई और मूल्य के बीच कम से कम एक व्हाट्सएप चरित्र होना चाहिए।
• जीत की कार्रवाई तब होती है जब प्रतिद्वंद्वी के पास शून्य या कम स्वास्थ्य होता है।
• किसी क्रिया के सभी भाग एक ही पंक्ति में होने चाहिए।
• प्रति पंक्ति एक क्रिया होनी चाहिए।
• सबसे कम बाइट्स जीतता है।

कोशिश करो!

Comments

ऐलिस (ए) और बॉब (बी) नाम मुझे नेटवर्क सुरक्षा वर्ग के लिए फ़्लैश बैक दे रहे हैं। अभिनेता ऐलिस (ए) कुंजी के साथ बॉब (बी) के लिए एक पैकेट भेजता है ... आदि ...

— मैजिक ऑक्टोपस उर्न

@MagicOctopusUrn वह है। वे आमतौर पर संवाद करने की कोशिश कर रहे हैं। जब संचार टूट जाता है, तो दुःखद संघर्ष अक्सर बढ़ता है।

— AJFaraday

मुझे उन दिनों की याद आती है जब हम यह जानने की कोशिश कर रहे थे कि मैलोरी से अपने रहस्यों को कैसे छिपाया जाए ... वे सरल समय थे ...

— Bob

@ याकूब मैलोरी वास्तव में एक व्याकुलता की चीज है। यह ईव है जिसे आपको देखने की जरूरत है।

— AJFaraday

@ msh210 अच्छी तरह से, कोड गोल्फ में महत्वपूर्ण विस्तार यह है कि हर कोई एक ही चुनौती लेता है, लेकिन यहाँ तर्क है: - यदि आप डनगन्स और ड्रेगन खेल रहे थे, तो आप कहेंगे "मैं गॉबलिन को किक करने जा रहा हूं", फिर आप ' डी प्रभावशीलता के लिए रोल, फिर रोल के परिणाम को लागू करें। एक रोल निरर्थक है अगर कोई नहीं जानता कि आप क्या रोल कर रहे हैं।

— AJFaraday

Answer 1

05AB1E , 49 बाइट्स

"BaABr0Aha"S3ô»D„AB‡[6LΩ©Tǝ¤H®-©16ǝ=®0‹#s]н…ÿ w?

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

व्याख्या

"BaABr0Aha"                                        # push the initial state of B
           S                                       # split to list of characters
            3ô                                     # divide into 3 parts
              »                                    # join each part on space and all on nl
               D„AB‡                              # make a copy with A and B inverted
                     [                             # start a loop
                      6LΩ©                         # pick a random number in [1 ... 6]
                          Tǝ                       # insert at position 10 of the string
                            ¤H                     # get the last char of the string and
                                                   # convert from hex
                              ®-©                  # subtract the random number
                                 16ǝ=              # insert at position 16 and print
                                     ®0‹#          # if the hp is less than 0, break
                                         s         # swap the other string to the stack top
                                          ]        # end loop
                                           н…ÿ w?  # print the winner

Answer 2

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

x,y="AB"
from random import*
X=Y=10
p=print
while X>0:p(x,"a",y);d=randint(1,6);p(x,"r",d);Y-=d;p(y,"h",Y);x,y,X,Y=y,x,Y,X
p(y,"w")

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

-8 बाइट्स ऑफिशियल
-२ धन्यवाद बाइट्स चोएजेरमी के लिए धन्यवाद

Comments

पूर्वनिर्धारितता p=printआपको लगभग 8 बाइट्स बचाएगी।

— राजकीय

चूँकि y हमेशा इस बिंदु पर जीतता है (और लूप में केवल X हमला करता है, जिसे बाद में Y को स्वैप कर दिया जाता है), आपको यह जांचने की आवश्यकता नहीं है कि क्या y खो गया है। - ChooJeremy - समीक्षा से

— NoOneIsHere

@NoOneIsHere मुझे पर संदेश भेजने के लिए धन्यवाद: डी

— HyperNeutrino

randint(1,6)के साथ प्रतिस्थापित किया जा सकता है id(X+Y)//3%6+1, हालांकि वितरण काफी समान नहीं है।

— विंसेंट

@Vincent मुझे नियमों को झुकाने की बात नहीं दिखती है अगर वह इसे कम करने में मदद नहीं करता है ...

— HyperNeutrino

Answer 3

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

f(A,B,r,t,a,b){for(A=B=10;r=1+clock()%6,A*B>0;t=!t)printf("%c a %c\n%c r %u\n%c h %i\n",a=65+t,b=66-t,a,r,b,t?A-=r:(B-=r));printf("%c w",a);}

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

डी-गोल्फ:

f(A,B,r,t,a,b){
    for(A=B=10; //Initialize HP
        r=1+clock()%6, // Get the number of processor cycles the program has consumed. This is relatively random, so I call it good enough.
        A*B>0;t=!t) // Flip t for change of turns
        printf("%c a %c\n%c r %u\n%c h %i\n", // Print the turn
            a=65+t,b=65+!t,a,r,b, // 65 is ASCII for 'A', 66 for 'B'
            t?A-=r:(B-=r)); // Deduct the damage.
    printf("%c w",a); // Print the winner
}

Comments

क्या आप एक बाइट का उपयोग करके बचा सकते हैं a=65+t,b=66-t?

— मोपेट

A*B>0आपको कुछ बाइट्स बचाएगा।

— ओलिवियर ग्राएगोइरे

A*Bऔर भी अधिक बचत होगी, लेकिन मैं जल्दी में एक तरह से हूँ। मैं शाम को अपडेट

पासा सेक में एक बग मिला {6,4,3,1,5}। b स्वास्थ्य के साथ जीतता है -4। TIO देखें मैंने इस बग को प्रदर्शित करने के लिए आपके पासा कैलकुलेटर को बदल दिया।

— जीपीएस

@GPS धन्यवाद, मैं अभी पैच कर दूँगा।

Answer 4

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

यह @HyperNeutrino उत्तर पर एक सुधार है जो एक टिप्पणी में फिट नहीं होगा। नीचे स्पष्टीकरण देखें।

x,y="AB"
s=id(0)
X=Y=10
p=print
while X>0:p(x,"a",y);s=s**7%~-2**67;d=s%6+1;p(x,"r",d);Y-=d;p(y,"h",Y);x,y,X,Y=y,x,Y,X
p(y,"w")

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

---

एक छोटे अजगर पासा रोल के लिए एक महाकाव्य खोज

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

मैं देखना चाहता था कि क्या मानक अजगर पासा रोल ( 32 बाइट्स ) को थोड़ा छोटा किया जा सकता है:

from random import*;randint(1,6)

विशेष रूप से, id(x)कार्यक्रम में कुछ गैर-निर्धारक मूल्य लाने के लिए काफी सुविधाजनक है। मेरा विचार तब कुछ वास्तविक यादृच्छिकता बनाने के लिए किसी तरह से इस मूल्य को हैश करने का था। मैंने कुछ तरीकों की कोशिश की, और उनमें से एक ने भुगतान किया: आरएसए एन्क्रिप्शन ।

आरएसए एन्क्रिप्शन, इसकी सादगी के कारण, केवल कुछ बाइट्स की आवश्यकता होती है m**e%n:। अगले यादृच्छिक मूल्य को पिछले एक को एन्क्रिप्ट करके बनाया जा सकता है। मान लिया जाये कि (e,n)कुंजी उपलब्ध है, पासा रोल के साथ लिखा जा सकता है 22 बाइट्स :

s=id(0);s=s**e%n;s%6+1

इसका मतलब है कि हमारे पास वैध RSA कुंजी को परिभाषित करने के लिए लगभग 10 बाइट्स हैं। यहां मैं भाग्यशाली रहा। अपने प्रयोगों के दौरान, मैंने केवल Mersenne प्राइम M67 का उपयोग करना शुरू किया, ताकि बाद में एहसास हो सके कि Mersenne ने अपनी सूची में M67 सहित एक गलती की। यह पता चला की उत्पाद होने के लिए p=193707721और q=761838257287। मुझे अपना मापांक मिला था:

n=~-2**67

अब, प्रतिपादक और चार्मिचेल टोटिएंट को कोप्राइम(p-1)*(q-1) करने की आवश्यकता है। सौभाग्य से फिर से, पहली अभाज्य संख्या जो n के कुल भाग को विभाजित नहीं करती है, केवल एक अंक लंबी है: 7. पासा रोल तब 28 बाइट्स का उपयोग करके लिखा जा सकता है (मानक दृष्टिकोण से कम 4 बाइट्स) :

s=id(0);s=s**7%~-2**67;s%6+1

M67 के साथ एक अच्छी बात यह है कि उत्पन्न यादृच्छिक मूल्य में 66 बिट्स हैं, जो सामान्य 64 बिट्स आरएनजी से अधिक है। इसके अलावा, आरएसए का उपयोग कई बार वर्तमान मूल्य को डिक्रिप्ट करके समय पर वापस जाना संभव बनाता है। यहाँ एन्क्रिप्टिंग और डिक्रिप्टिंग कुंजी हैं:

Encryption: (7,                    147573952589676412927)
Decryption: (42163986236469842263, 147573952589676412927)

मैं निश्चित रूप से सांख्यिकी या क्रिप्टोग्राफी का विशेषज्ञ नहीं हूं, इसलिए मैं वास्तव में यह नहीं बता सकता कि यह आरएनजी "अच्छा यादृच्छिक" के मानदंड की जांच करता है या नहीं। मैंने एक छोटा बेंचमार्क लिखा था जो विभिन्न आरएनजी का उपयोग करके 1 से 6 डाइस रोल की घटनाओं के मानक विचलन की तुलना करता है। ऐसा लगता है कि प्रस्तावित समाधान अन्य लोगों की तरह ही काम करता है।

Comments

प्रभावशाली काम! :)

— हाइपरनेत्रिनो

Answer 5

जावास्क्रिप्ट (ईएस 6), 122 बाइट्स

f=(h=[10,10,p=0])=>`${x='AB'[p]} a ${y='BA'[p]}
${x} r ${d=Math.random()*6+1|0}
${y} h ${H=h[p^=1]-=d}
${H<1?x+' w':f(h)}`

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

Answer 6

जावा (JDK 10) , 180 बाइट्स

v->{var r="";int p=0,H[]={10,10},h=0;for(;H[0]*H[1]>0;)r+=r.format("%3$c a %4$c%n%3$c r %d%n%4$c h %d%n",h+=Math.random()*6-h+1,H[p]-=h,p+65,(p^=1)+65);return r+(char)(66-p)+" w";}

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

क्रेडिट

• -8 बाइट्स केविन क्रूज़सेन को धन्यवाद

Comments

जावा 10 है var? o. o मुझे वास्तव में जल्द ही कुछ नए चश्मे की जांच करने की आवश्यकता है .. वैसे भी, आप 4 बाइट्स को चार-सरणी में बदलकर int-array कर सकते हैं:v->{var r="";int P[]={65,66},p=0,H[]={10,10},h=0;for(;H[0]*H[1]>0;)r+=r.format("%3$c a %4$c%n%3$c r %d%n%4$c h %d%n",h+=Math.random()*6-h+1,H[p]-=h,P[p],P[p^=1]);return r+=P[p^1]+" w";}

— केविन क्रूज़सेन

@KevinCruijssen हां, जावा 10 में var है। आगे पढ़ने की जरूरत नहीं है, यह मूल रूप से एकमात्र परिवर्तन है जो हमारे गोल्फरों के लिए उपयोग करने योग्य है। और नहीं, मैं वह नहीं कर सकता जो आप सुझाते हैं: परिणाम की अंतिम पंक्ति की जांच करें: यह 65 wइसके बजाय बन जाता है A w। इसलिए मैंने इसे इस int ...कथन से निकाला : कुछ बाइट्स गोल्फ के लिए ;-)

— ओलिवियर ग्राईगोइरे

@KevinCruijssen मैंने यहाँ कुछ उदाहरणों का अनुपालन किया: codegolf.stackexchange.com/a/159922/16236

— ओलिवियर

v->{var r="";int p=0,H[]={10,10},h=0;for(;H[0]*H[1]>0;)r+=r.format("%3$c a %4$c%n%3$c r %d%n%4$c h %d%n",h+=Math.random()*6-h+1,H[p]-=h,p+65,(p^=1)+65);return r+(p<1?"B":"A")+" w";}( 181 बाइट्स )

— केविन क्रूज़सेन

Answer 7

पर्ल 5 , 93 88 87 बाइट्स

$A=$B=10;$_=B;${$_^=v3}-=$%=1+rand 6,say"$_ a $'
$_ r $%
$' h $$_"until//>$$_;say"$_ w"

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

Answer 8

रूबी , 122 120 96 92 91 बाइट्स

f=->x=?A,y=?B,m=10,n=m{p [x,?a,y],[x,?r,r=1+rand(6)],[y,?h,t=n-r]
t<1?p([x,?w]):f[y,x,t,m]}

^{Asone Tuhid को 1 बाइट धन्यवाद दिया ।}

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

Comments

यह ऐसा है जैसे मैं यह भी नहीं जानता कि रूबी को और अधिक कैसे;)

— एजेराडाय

मुझे डर है कि आपका विकल्प काम नहीं करता है, "कार्रवाई के सभी हिस्सों को एक ही पंक्ति में होना चाहिए।" हालाँकि, क्या यह संभव हो सकता है कि टैब कैरेक्टर के साथ एक ही ऑप्टिमाइज़ेशन करें?

— AJFaraday

@AJFaraday क्या यह प्रारूप में उत्पादन लाइनों के लिए स्वीकार्य होगा ["A", "a", "B"]? यदि हां, तो मेरे पास यह 96-बाइट समाधान है।

— क्रिस्टियन लुपस्क्यू

यदि वे प्रति पंक्ति एक आउटपुट कर रहे हैं। ऐसा करना चाहिए।

— AJFaraday

-1 बाइट यदि आप के ?(p [x,?w]):साथ प्रतिस्थापित करते हैं?p([x,?w]):

— Asone Tuhid

Answer 9

जावा 8, 230 बाइट्स

v->{for(int h=104,a=h,x=0,y=1,A=10,B=A,r=0,t=0,T;a<119;)System.out.printf("%c %3$c %c%n",(x=a>h|A*B<1?x^1:x)+65,y=(a<98?t=r+=Math.random()*6-r+1:a>h?(T=x<1?A-=t:(B-=t))<0?0:T:A*B<1?-16:(x^1)+17)+48,a=a<98?114:a>h?104:A*B<1?119:97);}

ध्यान दें: पहले से ही एक बहुत छोटा जावा उत्तर है, इसलिए उसका उत्थान सुनिश्चित करें ! मैं हालांकि एक पूरी तरह से अलग दृष्टिकोण का उपयोग करता हूं, इसलिए लगा कि यह पोस्टिंग के लायक है।

स्पष्टीकरण:

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

v->{                     // Method with empty unused parameter and no return-type
  for(int h=104,         //  Temp integer with unicode for 'h' to save bytes
          a=h,           //  Second part (Action)
          x=0,           //  First part
          y=1,           //  Third part
          A=10,          //  Score player A, starting at 10
          B=A,           //  Score player B, starting at 10
          r=0,           //  Random dice-roll
          t=0,           //  Previous dice-roll
          T;             //  Temp integer
      a<119;)            //  Loop until there is a winner
     System.out.printf(  //   Print
      "%c %3$c %c,%n",   //    The three parts with spaces, and a new-line
      (x=                //    First part:
         a>h             //     If the previous action is 'r',
         |A*B<1?         //     or there is a winner:
           x^1           //      Change A→B or B→A
         :               //     Else:
          x)             //      A/B remains unchanged
       +65,              //     Add 65 to convert 0/1 to 65/66 (unicode values of A/B)
      (y=                //    Third part:
         (a<98?          //     If the previous action was 'a'
           t=r+=Math.random()*6-r+1
                         //      Roll the dice, and save it in `t`
          :a>h?          //     Else-if the previous action was 'r':
           (T=x<1?       //      If the first part changed to player A:
            A-=t         //       Subtract the previous dice-roll from A
           :             //      Else:
            (B-=t))      //       Subtract the previous dice-roll from B
           <0?           //      If this score is below 0:
            0            //       Use 0
           :             //      Else:
            T            //       Use this score
         :               //     Else (the previous action was 'h'):
          A*B<1?         //      Is there a winner:
           -16           //       Change the third part to a space
          :              //      Else:
           (x^1)+17)     //       Change the third part to the other player
       +48,              //     Add 48 to convert it to unicode
       a=                //    Second part:
         a<98?           //     If the previous action was 'a': 
          114            //      Change it to 'r'
         :a>h?           //     Else-if the previous action was 'r':
          h              //      Change it to 'h'
         :               //     Else (the previous action was 'h'):
          A*B<1?         //      If either score is 0:
           119           //       Use 'w'
          :              //      Else:
           97);}         //       Use 'a'

Answer 10

सी (जीसीसी) , 142 बाइट्स

#define R(c,t)r=rand()%6+1,c&&printf(#c" a "#t"\n"#c" r %d\n"#t" h %d\n",r,t-=t<r?t:r),t||puts(#c" w")
f(A,B,r){for(A=B=10;A*B;R(B,A))R(A,B);}

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

Comments

बस एक समस्या, यह एक जीत में समाप्त नहीं हुई।

— AJFaraday

@AJFaraday ओह हाँ, तय हो गया।

— nwellnhof

Answer 11

बैच, 174 बाइट्स

@set/aA=B=10
@set c=A
@set d=B
:g
@set/ar=%random%%%6+1,h=%d%-=r
@echo %c% a %d%
@echo %c% r %r%
@echo %d% h %h%
@if %h% gtr 0 set c=%d%&set d=%c%&goto g
@echo %c% w

स्पष्टीकरण: % चर संदर्भों को पार्स समय पर प्रतिस्थापित किया जाता है। इसके दो उपयोगी लाभ हैं:

• %d%-=r घटाता rद्वारा नामित चर से हैd (यानी अप्रत्यक्ष संदर्भ)
• set c=%d%&set d=%c% बस एक सीधा स्वैप है।

Answer 12

PHP 7.1: 159 बाइट्स

<?php $A=$B=10;$t='AB';while($A>0&&$B>0){$a=$t[0];$b=$t[1];$d=rand(1,6);$$b-=$d;echo"$a a $b\n$a r $d\n$b h {$$b}\n";$t=strrev($t);}echo($A>0?'A':'B')." w\n";

इसे यहां ब्राउज़र में चलाएं!

PHP 5.6: 156 बाइट्स

<?php $A=$B=10;$t='AB';while($A>0&&$B>0){list($a,$b)=$t;$d=rand(1,6);$$b-=$d;echo"$a a $b\n$a r $d\n$b h {$$b}\n";$t=strrev($t);}echo($A>0?'A':'B')." w\n";

इसे यहां ब्राउज़र में चलाएं!

यहाँ प्रारूप और टिप्पणियों के साथ PHP 5.6 समाधान कैसा दिखता है:

<?php
// Initialize both HP counters
$A = $B = 10;

// Set the turn order as a string (which 5.6 allows to be unpacked into a list)
$t = 'AB';

// Run this loop as long as both players have HP
while ($A > 0 && $B > 0) {
    // Unpack the turn string into $a and $b variables; on the first run, $a = 'A'
    // and $b = 'B'. This is no longer possible in PHP 7.0, so the PHP 7.0
    // solution needed to use an array instead.
    list($a, $b) = $t;

    // Set damage to a random number between 1 and 6
    $d = rand(1, 6);

    // Subtract the damage from the referenced value $b. On the first turn, this
    // is 'B', so this ends up subtracting $d from $B. Next turn, $b will be 'A',
    // so it'll subtract $d from $A
    $$b -= $d;

    // Echo the string (interpolated values)
    echo "$a a $b\n$a r $d\n$b h {$$b}\n";

    // Reverse the turn order string ('AB' becomes 'BA', which will affect the
    // call to list in the first line of the while-loop)
    $t = strrev($t);
}

// Someone's run out of HP; figure out whom by figuring out who still has HP
echo ($A > 0 ? 'A' : 'B') . " w\n";

Answer 13

बैश, 178 बाइट्स

A=10 B=10 e=echo
a(){ $e $1 a $2;d=$((RANDOM%6+1));$e $1 r $d;eval $2=$((${!2}-$d));$e $2 h ${!2};[ ${!2} -gt 0 ];}
while a A B && a B A;do cd;done;[ $A -gt 0 ]&&$e A w||$e B w

Answer 14

एफ #, 238 235 बाइट्स

मुझे लगा कि मैं अच्छा कर रहा हूं, लेकिन आपने मुझे बहुत पीछे छोड़ दिया है!

let p=printfn
let mutable A=10
let mutable B=A
let x h a d=
 p"%s a %s"a d
 let i=(new System.Random()).Next(1,7)
 let j=h-i
 p"%s r %i"a i
 p"%s h %i"d j
 if j<=0 then p"%s w"a
 j
while A*B>0 do
 B<-x B"A""B"
 if B>0 then A<-x A"B""A"

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

रोजम के लिए धन्यवाद ए> 0 && बी> 0 (3 बाइट्स से दूर) के बजाय ए * बी> 0 का उपयोग करने की शानदार सलाह के लिए।

आधिकारिक रूप से भी आपको धन्यवाद, जिनके पाइथन जवाब में प्रिंटफ को पूर्वनिर्धारित करने के संकेत ने मुझे कुछ बाइट्स दाढ़ी बनाने में भी मदद की।

Comments

एक सलाह जो मुझे @OlivierGregoire से मिली: A*B>0आपको कुछ और बचाएगी।

यह बिल्कुल शानदार है। इसे प्यार करना। आपका बहुत बहुत धन्यवाद!

— सियारान_मकरथी

Answer 15

हास्केल , 204 बाइट्स

हास्केल के साथ मेरा प्रयास, मैं दुर्भाग्य से इसे और अधिक प्रतिस्पर्धी बनाने में सक्षम नहीं था

import System.Random
main=getStdGen>>= \g->putStr$q(randomRs(1,6)g)10(10::Int)"A ""B "
(!)=(++)
l="\n"
q(x:z)a b p o=p!"a "!o!l!p!"r "!show x!l!o!"h "!show n!l!if n<1then p!"w"else q z n a o p where n=b-x

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

स्पष्टीकरण:

import System.Random  --import random module
main=                        --main function, program entry point
 getStdGen                   -- get the global random number generator
   >>= \g->                  --using the random generator g
       putStr $ q            --print the result of function q, passing in ..
          (randomRs (1,6) g) --an infinite list of random numbers, 1 to 6 generated by g
           10 (10::Int)      --the starting health of both players, 
                             --type annotation sadly seems to be required
           "A " "B "         --The names of the players,
                             --with an extra space for formatting
(!)=(++) --define the operator ! for list (String) concatenation, 
         -- we do this a lot so we save a bit by having a one byte operator
l="\n"   -- define l as the newline character

q      --define function q                         
 (x:z) --our list of random numbers, split into the next number (x) and the rest (z)
 a     -- the health of the active player
 b     -- the health of the player getting attacked
 p     -- the name of the active player
 o     -- the name of the player getting attacked
=
  p!"a "!o!l --create the attack action string with a newline
 !p!"r "!show x!l -- append the roll action
 !o!"h "!show n!l -- append the health remaining
 !           -- append the result of the following if
  if n<1     -- if the player being attacked has been defeated
  then p!"w" -- append the win string for the active player
  else q z n a o p  --otherwise append the result of calling q again with 
                    --rest of the random numbers, and the active players swapped
  where n=b-x -- define the attacked player's new health n
              -- their current health b - the random roll x

Comments

आप हास्केल में गोल्फ के लिए हमारे सुझावों पर एक नज़र डाल सकते हैं । जैसे where m=b-xकिसी पहरे में रखा जा सकता है |m<-b-x=:।

— लकोनी

आप कुछ मानकों उलटफेर द्वारा कोष्ठकों के लैम्ब्डा और एक सेट खो सकते हैं: main=putStr=<<q"A "10"B "10.randomRs(1,6::Int)<$>getStdGen। आप एक सूची का उपयोग भी कर सकते हैं और इसे फिर से परिभाषित करने के लिए संक्षिप्त कर सकते हैं (++)। पिछले जहाँ सिर्फ b-xहर जगह का उपयोग करने के लिए फायदेमंद नहीं लगता है।

— एंग्स

Answer 16

जूलिया 0.6 , 175 बाइट्स

p=println()
f(l="AB",h=[10,10],a=1)=(while min(h...)>0;d=3-a;p(l[a]," a ",l[d]);r=rand(1:6);h[d]-=r;p(l[a]," r ",r);p(l[d]," h ",max(h[d],0));a=d;end;p(l[findmax(h)[2]]," w"))

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

लंबा, बिना ढका हुआ संस्करण:

function status(player, health)
    println("$player h $(max(0,health))")
end

function roll(player)
    x = rand(1:6)
    println("$player r $x")
    x
end

function play()
    players = ["A","B"]
    healths = [10, 10]
    attacker = 1

    while min(healths...) > 0
        println("$(players[attacker]) a $(players[3-attacker])")
        healths[3-attacker]-=roll(players[attacker])
        status(players[3-attacker], healths[3-attacker])

        attacker = 3 - attacker
    end

    winner = findmax(healths)[2]
    println("$(players[winner]) w")
end

Comments

आपके TIO लिंक में कोई आउटपुट नहीं लगता है।

— एजेफराडे

हाँ, मुझे नहीं पता कि टियो को यह पसंद क्यों नहीं है। यह मेरी मशीन पर बढ़िया काम करता है। अगर मेरे पास समय है तो मैं इसे देखूंगा।

— ०५:२३ पर niczky12

Answer 17

VBA, 222 185 179 बाइट्स

इस पुनरावर्ती समाधान में 3 उप शामिल हैं

1. जी खेल की शुरुआत है जो पहली बारी से किक मारता है
2. t को प्रत्येक के लिए कहा जाता है मोड़ के । यह पुनरावृत्ति का उपयोग करता है।
3. p डिबग से छोटा है। जब 3 से अधिक बार उपयोग किया जाता है (केवल इस समाधान में 4) संपादित करें: अब जब मैंने सीखा कि Debug.?यह स्वीकार्य विकल्प है Debug.Print,Debug.?x तो प्रिंट करने के लिए सब को कॉल करने की तुलना में कम है।

Sub g()
t "A",10,"B",10
End Sub
Sub t(i,j,x,h)
d=Int(Rnd()*6)+1
Debug.?i &" a "&x
Debug.?i &" r "&d
h=h-d
If h<1Then
Debug.?i &" w"
Else
Debug.?x &" h "&h
t x,h,i,j
End If
End Sub

यह एक मजेदार चुनौती थी। यदि आपको VB6 / VBScript / VBA के लिए TIO जैसे ऑनलाइन दुभाषिया का पता है तो कृपया एक टिप्पणी छोड़ दें। फिर मैं एक काम कर रहे समाधान के लिए एक लिंक पोस्ट कर सकता हूं।

यदि आप इस कोड का परीक्षण करना चाहते हैं और Microsoft Excel, Word, Access या Outlook स्थापित (केवल Windows) है, तो VBA IDE खोलने के लिए Alt + F11 दबाएँ। एक नया कोड मॉड्यूल (Alt + I, M) डालें और विकल्प स्पष्ट करें। फिर कोड में पेस्ट करें और इसे चलाने के लिए F5 दबाएं। परिणाम तत्काल विंडो में दिखाई देने चाहिए (यदि आप इसे नहीं देखते हैं तो Ctrl + G दबाएं)।

संपादित करें 1: हटाए गए व्हाट्सएप जो VBA संपादक में स्वचालित रूप से वापस जुड़ जाएंगे। 37 बाइट्स से घटाया जाता है
2: निकाले जाने के बाद 6 बाइट्स को बचाने के लिए सब पी () * को हटा दिया Debug.?जाना एक स्वीकार्य विकल्प है Debug.Print। एक कॉलिंग उप संभाल करने Debug.?केवल छह से अधिक कॉल के बाद बाइट्स बचाता है।