रूसी रूले, रीलोडेड

32

चलो रूसी रूले खेलते हैं!

आम तौर पर, यह सबसे छोटा MOD 6 प्रोग्राम लिखने की दौड़ होगी, लेकिन यह बहुत यथार्थवादी नहीं है, क्योंकि जीतने की संभावना प्रत्येक क्लिक के साथ कम हो जाती है। ये नियम हैं:

  1. एक वास्तविक छह-शूटर का अनुकरण करें :
    • एक सिंगल बुलेट को छह कक्षों में से एक में रखा जाता है, और बैरल को एक बार बजाया जाता है, केवल खेलने से पहले।
    • N वें प्रयास पर हारने का मौका 1/6 है।
    • N कोशिशों के बाद खोने का मौका 1 / (6-n) है
    • आपको कम से कम, 6 कोशिशों में हार की गारंटी है।
  2. हार:
    • पाठ प्रदर्शित करें *BANG!*
    • कार्यक्रम को समाप्त करें।
  3. जीतना:
    • "जीतने" का अर्थ है कि बंदूक में आग नहीं है, लेकिन गोली हथौड़ा के करीब एक कक्ष है।
    • पाठ प्रदर्शित करें *click*
    • कार्यक्रम को समाप्त करने की क्षमता के साथ उपयोगकर्ता को "ट्रिगर" पेश करें (उदाहरण के लिए "ctrl + c", नीचे देखें)।
  4. कार्यक्रम विशिष्ट:
    • ट्रिगर खींचना उपयोगकर्ता इनपुट का कुछ रूप है, जिसमें पहला प्रयास भी शामिल है। (यह एक कीस्ट्रोक, एक माउस क्लिक, जो कुछ भी हो सकता है; पाठ संकेतों की आवश्यकता नहीं है।)
    • कार्यक्रम के केवल एक उदाहरण की अनुमति है जब तक कि इसे समाप्त नहीं किया जाता है। (कार्यक्रम का एक नया उदाहरण रनिंग बैरल को एक अच्छा स्पिन देने के लिए महत्वपूर्ण है, यानी अगले क्लिक पर खोने की संभावना 1/6 पर रीसेट है।)

सबसे छोटा कोड जीतता है!

लीडरबोर्ड

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

code-golf  game  random 
— ayane
स्रोत
3
आपकी धारणा गलत है - यदि आप प्रत्येक शॉट के बाद गोलियों का जवाब देते हैं, तो n'th कोशिश में हारने की संभावना केवल - है। हारने की संभावना के बिना पहले शॉट पर chance, दूसरे पर chance, तीसरे पर chance ... 6 पर 1 में समाप्त होता है। आप इसे "आप में हारने की गारंटी देते हैं, सबसे अधिक, 6 कोशिशें" करते हैं।
— रिआल्टो
2
@ user2956063 आप भूल रहे हैं कि एक (n-1) / 6 मौका है कि आप कभी भी n तक नहीं पहुँचते हैं: th try, और इस प्रकार हार नहीं सकते। वे एक समान 1/6 को संतुलित करते हैं।
— याकूब रायहल
2
हो सकता है कि कंप्यूटर वैज्ञानिकों और सांख्यिकीविदों के इस तरह से अंतर होने की संभावना हो - तो मेरे लिए "nth कोशिश पर हारने का मौका is है" यह निरंतर है - चाहे n 1 या 100 हो
— rhialto
3
यह "रूसी रूले, रीलोडेड" शीर्षक क्यों नहीं था?
— हैंड-ई-फूड
1
@ user2956063: आपकी संभावनाएं सशर्त हैं । P (शॉट 2 पर हारना) = 2, लेकिन P (शॉट 2 पर हारना; शॉट 1 पर हारना नहीं था) = 2। इसके अलावा, n(स्पष्ट रूप से, मैं आपको अनुदान दूंगा) [1,6] तक सीमित है, इसलिए 100 बाहर है।
— टिम पैडरिक

जवाबों:

3

पायथ, 23 बाइट्स

VO6"*click*" w;"*BANG!*

वास्तव में सरल। पुनरावृत्तियों की एक यादृच्छिक संख्या 0 - 5 प्रदर्शन क्लिक करें और इनपुट की एक पंक्ति का अनुरोध करें, जिसके बाद अंत में एक धमाका होता है।

— isaacg
स्रोत
1
धिक्कार है तुम्हें, अजगर!
— साइओस
+3 बाइट्स: अंतिम तार होना चाहिए *BANG!*, नहींBANG
— ayane
14

रूबी, 51 बाइट्स

[*['*click*']*rand(6),'*BANG!*'].map{|x|gets;$><<x}

Ungolfed:

[
  *(                        # Unwrap the following array into the outer one
    ['*click*'] * rand(6)   # An array of 0-5 clicks, see Array#*
  ),
  '*BANG!*'                 # The End
].map do |x| # Shortest way to iterate I was able to find
  gets       # Await input
  $> << x    # Shove the output string to `stdout`
end          # Return value is an array of several (0-5) `stdout`s. Who cares.

या

(['*click*']*rand(6)<<'*BANG!*').map{|x|gets;$><<x}

पाठकों के लिए अधूरा छोड़ना। मुश्किल नहीं है

  • मार्टिन के लिए एक बार फिर, $><<एक putsप्रतिस्थापन के रूप में चाल के लिए इस बार ।
  • उत्पादन नहीं करता है newlines, लेकिन यह आवश्यक नहीं था।
  • छोटा, सरल। आवश्यक व्यवहार का सार 0-5 क्लिक और फिर आग करना है। उसके लिए, आउटपुट ऐरे के अंदर जमा होते हैं।
  • 2 और बाइट्स बंद मुंडा जा सकता है अगर आउटपुट चाहते "*click*"ठीक हैं (क्या आवश्यक है अंत में छापा जाता है) की जगह मिल द्वारा $><<के साथ p । मुझे यकीन नहीं था कि यह अभी भी नियमों का पालन करेगा।

68 64 बाइट्स

(एक अन्य दृष्टिकोण)

[*0..5].shuffle.find{|x|gets;x<1||puts('*click*')};puts'*BANG!*'

मैंने एल्गोरिथ्म में बहुत सोचा नहीं था (यह संभवतः और भी अधिक कॉम्पैक्ट हो सकता है, लेकिन इतना स्पष्ट नहीं है), लेकिन मुझे वास्तव में अंदर का मॉडल पसंद है:

  • एक सरणी अपने तत्वों के कक्षों की सामग्री के साथ एक बैरल का अनुकरण करती है। चूंकि केवल एक तत्व एक गोली है, इसे घुमाने और इसे फेरने के बराबर है।
  • 0एक गोली है। अन्य संख्याएँ नहीं हैं।
  • findपहला रिटर्न मान पाता है जिसके लिए ब्लॉक न तो है falseऔर न ही है nil।
  • ||-प्रतिरोध का तात्पर्य ब्लॉक से वापस लौटना है। यह एक शॉर्ट सर्किट बताया गया है: यह अपनी पहली संकार्य रिटर्न (जब तक यह है nilया false) या एक दूसरे (अन्यथा)। तो यह या तो true(यदि x<1या तो स्पष्ट, लेकिन लंबे समय तक x == 0) या रिटर्न वैल्यू का रिटर्न देता है puts, जबकि ...
  • putsहमेशा लौटता है nil। हां।
  • getsइनपुट का अनुरोध करता है। खूब मार Enterझेलता है।
  • Ctrl+ Cकार्यक्रम को समाप्त करता है
— डी-पक्ष
स्रोत
64 को पार करना सामान्य 64 है?
— साइओस
@Cyoce उम्म ... हाँ। होना चाहिए, शायद। यह उपर्युक्त प्रविष्टि द्वारा सुपरिडेट किया गया है, लेकिन यह एक अलग विचार पर आधारित है, इसलिए मैंने उन्हें छोड़ दिया, पार किया।
— डी-साइड
यह इस
— Cycece
@Cyoce ओह, मुझे क्षमा करें, पहली पोस्ट और वह सब, जो स्थानीय विद्या से अवगत नहीं है :)
— D-side
9

जावास्क्रिप्ट, 64 बाइट्स

for(i=6;i<7&&prompt();)alert(new Date%i--?"*click*":i="*BANG!*")

व्याख्या

ट्रिगर खींचने के लिए किसी भी टेक्स्ट को प्रॉम्प्ट में दर्ज करें। कुछ भी दर्ज न करें या रद्द करने के लिए रद्द करें पर क्लिक करें।

for(
  i=6;             // i = number of chambers
  i<7              // i equals "*BANG!*" (not less than 7) if we lost
    &&prompt();    // see if we should do another shot
)
  alert(           // alert the result
    new Date%i--   // use the current time in milliseconds as a random number, this is safe
                   //     to use because the gap between shots is greater than i (max 6ms)
      ?"*click*"   // on win pass "*click*" to alert
      :i="*BANG!*" // on lose alert "*BANG!*" and set i to not less than 7
  )
— user81655
स्रोत
"*Bang!*"7 से अधिक नहीं है। लेकिन NaN
— 7.38
@ बरगी यह सच है। मैंने इसे थोड़ा स्पष्ट करने के लिए स्पष्टीकरण को फिर से प्रस्तुत किया।
— user81655
6
@ जावास्क्रिप्ट केवल जावास्क्रिप्ट में यह कथन समझ में आता है।
— माइकइलियार
7

लूआ, 82 75 बाइट्स

बहुत लंबा है, लेकिन लुआ में बहुत क्रिया है।

for a=math.random(6),1,-1 do io.read()print(a>1 and"*click*"or"*BANG!*")end
— Katenkyo
स्रोत
6

लैबव्यू, 46 लैब व्यू आदिम

0 और 1 1 का एक एरे बनाता है, जिसमें क्लिक का इंतजार करने और स्ट्रिंग को आउटपुट करने के लिए एक लूप होता है। यह शुरू में कहता है कि बेंंग आरसुसे मैं इसे शुरू करने से पहले संकेतक को रीसेट करना भूल गया।

यह भी ध्यान दें कि यह एक जिफ है, अगर आपके लिए पेज लोड नहीं होता है तो कृपया पुनः लोड करें।

— Eumel
स्रोत
"*click*"अगर बंदूक नहीं चलती तो मैं यह नहीं देखता कि आप आउटपुट कहाँ करते हैं । इसके अलावा, यह उत्पादन करता है "bang"या "*BANG!*"?
— कैटेन्को
यह एक जिफ होना चाहिए लेकिन मेरे लिए यह नहीं खेलता है, कि समस्या हो सकती है। और हाँ, यह केवल धमाका करता है, कि मैं ठीक से नहीं पढ़ रहा था मैं इसे एक सेकंड में बदल देता हूँ
— Eumel
बेवकूफ मुझे शुरू करने से पहले स्ट्रिंग को फिर से संगठित करना भूल गया, इसलिए यह शुरुआत में बैंग दिखाता है ...
— यूमेल
कोई बात नहीं, मैंने अब gif देखा, ऐसा लगता है कि यह बहुत अच्छी तरह से काम करता है :)
— Katenkyo
5

पायथ, 31 30 28 बाइट्स

FN.S6 EI!N"*BANG!*"B"*click*

लगभग निश्चित रूप से सुधार किया जा सकता है। जल्दी, एक त्रुटि के साथ समाप्त करने के लिए ट्रिगर, रिक्त इनपुट खींचने के लिए किसी भी संख्या में इनपुट करें।

स्पष्टीकरण:

FN                               for N in...
  .S6                            shuffle(range(6))...
      E                          get a line of input
       I!N                       if N is falsy (i.e. 0)
          "*BANG!*"              implicit output
                   B             break
                    "*click*     else, print click
— Doorknob
स्रोत
आपका पहला व्यक्ति वास्तव में छोटा है, आपको अनुगामी की आवश्यकता नहीं है "।
— FryAmTheEggman
@FryAmTheEggman ओह, ठीक है, उस के बारे में भूल गया। धन्यवाद!
— दरवाज़े
इसके अलावा, मैंने बस कुछ मूर्खतापूर्ण देखा है, FN<any>अभी भी पूरी तरह से समान है V<any>, जिसे शायद नए गोल्फरों को भ्रमित करने के लिए नहीं बदला जाना चाहिए ...: P
— FryAmTheEggman
1
आप केवल वर्ण हटा सकते हैं .?। इसके लिए कोई जरूरत नहीं है else।
— जकुबे
@FryAmTheEggman लोगों को भ्रमित करना कमाल है। यह स्क्रब को छानने में अद्भुत हो सकता है ।
— साइओस
5

गंभीरता से, 27 25 बाइट्स

"*BANG!*"6J"*click*"nW,X.

कोई ऑनलाइन लिंक नहीं है क्योंकि पाइप किए गए इनपुट के साथ प्रॉम्प्ट करने का कोई तरीका नहीं है। चिकन को समाप्त करने के लिए कार्यक्रम किसी भी समय CTRL-C'd हो सकता है ।

स्पष्टीकरण:

"*BANG!*"6J"*click*"nW,X.
"*BANG!*"                  push "*BANG!*"
         6J                push a random integer in [0,6) (n)
           "*click*"n      push "*click*" n times
                     W     while loop (implicitly closed at EOF):
                      ,X.    get input and discard, pop and print top of stack
— मेगो
स्रोत
4

PHP, 52 बाइट्स

*<?=$n=&rand(0,6-$argi)?click:"BANG!*";$n||@\n?>*

-Fकमांड लाइन विकल्प की आवश्यकता होती है , जिसे तीन के रूप में गिना जाता है। ट्रिगर दबाकर खींचा जाता है Enter।

क्योंकि -Fशाब्दिक रूप से हर इनपुट के लिए स्क्रिप्ट फिर से चलती है (मैं आपको बच्चा नहीं), dieऔर जैसे वास्तव में समाप्त नहीं होगा, इसलिए हम इसके बजाय रनटाइम त्रुटि के माध्यम से बाहर निकलते हैं @\n।

नमूना उपयोग

$ php -F primo-roulette.php

*click*
*click*
*BANG!*
$
— Primo
स्रोत
4

पर्ल 5, 43 बाइट्स

साथ चलाना perl -p। स्थिर बुलेट संस्करण - यानी बुलेट की स्थिति बहुत शुरुआत में केवल एक बार तय की जाती है।

$i//=0|rand 6;$_=$i--?'*click*':die'*BANG*'
— ओलेग वी। वोल्कोव
स्रोत
अच्छा! मैं हेडर को "पर्ल 5.10+" में बदल दूंगा, क्योंकि आप उपयोग कर रहे हैं //=। इसके अलावा, अपने स्कोर में गिनती-p करना न भूलें ।
— ThisSuitIsBlackNot
4

सी, 110 74 72 बाइट्स

शामिल और बहुत कम बाइट्स से छुटकारा पाने के लिए डेनिस के लिए धन्यवाद।

main(r){for(r=time(0)%6;getchar(),r--;)puts("*click*");puts("*BANG!*");}
main(r)
{
    for(r=time(0)%6;getchar(),r--;)
        puts("*click*");
    puts("*BANG!*");
}
— रेनर पी।
स्रोत
3

कैंडी , 36 बाइट्स

लगभग आधे कार्यक्रम को प्रिंट करने का पाठ है :(

:6H_(=b"*click*"(;):=)"*BANG!*\n"(;)

लंबा फार्म:

getc
digit6 rand range0  # build a range from 0 .. rand#
while
  popA              # these are the *click* instances  
  stack2
  "*click*"
  while
    printChr
  endwhile
  getc
  popA
endwhile
"*BANG!*\n"         # out of luck
while
  printChr
endwhile
— डेल जॉनसन
स्रोत
3

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

इसके अलावा मेरा पहला गोल्फ प्रयास, पायथन 3 में भी। मैंने ब्रूस को शपथ दिलाई और मैं एक ही व्यक्ति नहीं हूं।

from random import*
for a in range(randint(0,5)):input();print("*click*")
input();print("*bang*")

Ungolfed:

from random import*
for a in range(randint(0,5)):
    input()
    print("*click*")
input()
print("*bang*")

0 और 5 समावेशी के बीच एक यादृच्छिक संख्या उत्पन्न करें , कई बार प्रिंट क्लिक करें , फिर बैंग प्रिंट करें । ट्रिगर खींचने के लिए एंटर / रिटर्न दबाएं।

— स्टीव एकर्ट
स्रोत
ब्रूस के उदाहरण के बाद, आप कुछ बाइट्स बचा सकते हैंfrom random import*
— wnnmaw
जब तक मुझे कुछ और याद आ रहा है, यह बचत का एक बाइट है। लेकिन मैं इसे ले जाऊंगा! धन्यवाद!
— स्टीव एकर्ट
अच्छा प्रयास है, मैंने आपके समाधान का उपयोग मेरे अजगर 2 समाधान के लिए एक प्रेरणा के रूप में किया है ^ ^
— बेसाइल-हेनरी
2

एमएसीएस लिस्प, 94 89 बाइट्स

(set'b(%(random)6))(dotimes(a(+ b 1))(read-string"")(message(if(eq a b)"BANG""*click*")))

Ungolfed:

(set 'b (% (random) 6))
(dotimes (a (+ b 1))
  (read-string"")
  (message (if (eq a b) "BANG" "*click*")))
— भगवान युमा
स्रोत
2

आर, 86 80 77 बाइट्स

हमेशा की तरह, आर में गोल्फ को कोड करने के लिए कमाल के फीचर्स हैं लेकिन लुओओओन्ग फंक्शन नाम हैं।

sapply(sample(0:5),function(n){!n&&{cat('*BANG!*');q()};readline('*click*')})
— दुरुम
स्रोत
2

पायथन 2, 108 104 102 100 98 बाइट्स

गोल्फ में मेरा पहला प्रयास:

from random import*
a=[1]+[0]*5
shuffle(a)
for i in a:input();print("*click*","*BANG!*")[i];" "[i]

शायद मुझे यह जोड़ना चाहिए कि जब आप हारते हैं तो कार्यक्रम सही ढंग से समाप्त नहीं होता है , यह सिर्फ एक अपवाद (जिसके परिणामस्वरूप समाप्ति) होता है:

Traceback (most recent call last):
  File "russian_roulette.py", line 4, in <module>
    for i in a:input();print("*click*","*BANG!*")[i];" "[i]
IndexError: string index out of range
— ბიმო
स्रोत
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! जब आप एक कोड गोल्फ उत्तर पोस्ट करते हैं, तो कृपया भाषा का नाम और बाइट काउंट शामिल करें (मैंने इसे आपके लिए यहां संपादित किया है)। धन्यवाद!
— प्रोग्रामफॉक्स
हाँ, बहुत बहुत धन्यवाद! मैं वास्तव में उस मुद्दे को हल करने की कोशिश कर रहा था, इससे पहले कि आप इसे ठीक से संपादित न करें।
— ।
मुझे आपकी बाइट गिनती 112 के रूप में मिलती है , आपने क्या इस्तेमाल किया?
— wnnmaw
इसके अलावा, आप 2 बाइट्स को बचाकर कर सकते हैंa=shuffle([1,0,0,0,0,0])
— wnnmaw
1
जहाँ तक मुझे पता है कि फेरबदल अंतर्निहित डेटा संरचना को बदलता है और कुछ भी वापस नहीं करता है। मैंने कोशिश की कि, वैसे भी धन्यवाद। शीर्षक (भाषा और बाइट गिनती) ProgramFOX द्वारा लिखा गया था। लेकिन जब मैं इसका उपयोग wcकरता हूं तो मुझे 109 मिलता है जो बहुत अधिक है, इसलिए यह सही है। कैसे गिनोगे?
— ბიმო
2

पर्ल 5, 40 बाइट्स

<>,print"*$_*"for(click)x rand 5,'BANG!'

कमांड लाइन विकल्पों के बिना चलाएं, ट्रिगर दबाकर खींचा जाता है Enter।

— Primo
स्रोत
2

पायथन, 81 बाइट्स

import time
for i in["*click*"]*(int(time.time())%6)+["*BANG!*"]:input();print(i)

रूबी (51) और पायथन समाधान से प्रेरित है

— लार्स
स्रोत
1

आम लिस्प, 109

(do(g(b(nthcdr(random 6)#1='(t()()()()() . #1#))))(g)(read-char)(princ(if(setf g(pop b))"*BANG!*""*click*")))

बहुत प्रतिस्पर्धी नहीं है, लेकिन मुझे परिपत्र सूची पसंद है:

(do (;; auxiliary variable x
     x
     ;; initialize infinite barrel, rotate randomly
     (b (nthcdr (random 6) #1='(t()()()()() . #1#))))

    ;; we end the loop when x is T (a bullet is fired)
    (x)

  ;; press enter to shoot
  (read-char)

  ;; pop from b, which makes b advance down the list. The popped value
  ;; goes into x and is used to select the appropriate string for
  ;; printing.
  (princ
   (if (setf x(pop b))
       "*BANG!*"
       "*click*")))
— कोर निपात
स्रोत
1

पर्ल 5, 43 बाइट्स

42 बाइट्स + -pकमांड लाइन विकल्प। बस enterट्रिगर करने के लिए दबाएँ ।

$_=0|rand 7-$.<++$i?die"*BANG!*":"*click*"

उनकी मदद के लिए डोम हेस्टिंग्स को धन्यवाद! मूल उत्तर 67 बाइट्स था:

$i++;$a=$i>=int(rand(6));print$_=$a?'*BANG!*':'*click*';last if($a)
— Codefun64
स्रोत
वास्तव में इसके साथ समस्या -pयह थी कि यह आखिरी printकथन कहने से पहले बाहर निकल जाएगा , निश्चित नहीं कि क्यों। मैंने इसे आजमाया है। इसके अलावा, भयानक सुझाव, धन्यवाद! मेरा ज्ञान बढ़ता जा रहा है ...
— संहिता
@DomHastings इसके अलावा, दुर्भाग्यवश, किसी कारण से यह 0|ट्रिक उम्मीद के मुताबिक काम नहीं कर पाई, लेकिन मैंने इसमें से कुछ बाइट्स को शेव कर लिया, प्रिंट स्टेटमेंट और आखिरी स्टेटमेंट जैसा आपने सुझाया था। अब कैसा दिखता है?
— कोडफुन 64
@DomHastings धिक्कार है, आप अच्छे हैं। मैं सुझाव देता हूं कि अपने जवाब के रूप में, चूंकि आपने निश्चित रूप से एक छोटा सा कार्यक्रम लिखा था (मेरे मूल 67 की तुलना में आपके पास 40 बाइट्स हैं!)
— कोडफुन 64
मैं स्पष्टीकरण की सराहना करता हूं! मेरी पसंदीदा स्क्रिप्टिंग भाषा के और अधिक जानने के लिए हमेशा खुश! मैं भी प्रीफेक्स वेतन वृद्धि के बारे में कभी नहीं जानता था, यह बहुत बढ़िया है। धन्यवाद :)
— Codefun64
आपका बहुत स्वागत है, खुशी हुई कि आपने मदद की!
— डोम हेस्टिंग्स
1

MATL , 41 बाइट्स

6Yr`j?t@=?'*BANG!*'DT.}'*click*'DT]}T.]]x

ट्रिगर खींचने के लिए, एक गैर-रिक्त स्ट्रिंग (जैसे 'try') इनपुट करें ।

समाप्त करने के लिए, एक रिक्त स्ट्रिंग इनपुट करें

उदाहरण

इस मामले में ट्रिगर एक बार खींचा गया था और ... दुर्भाग्य:

>> matl
 > 6Yr`j?t@=?'*BANG!*'DT.}'*click*'DT]}T.]]x
 > 
> try
*BANG!*

इस मामले में उपयोगकर्ता ने दो भाग्यशाली खींचने के बाद (अंतिम खाली इनपुट को नोट करें) बंद कर दिया:

>> matl
 > 6Yr`j?t@=?'*BANG!*'DT.}'*click*'DT]}T.]]x
 > 
> try
*click*
> try
*click*
>

व्याख्या

6Yr                  % random avlue from 1 to 6    
`                    % do...while  
  j                  % input string
  ?                  % if nonempty
    t                % duplicate the orignal random value
    @                % loop iteration index  
    =                % are the equal?
    ?                % if so             
      '*BANG!*'D     % display string
      T.             % unconditional break                                     
    }                % else
      '*click*'D     % display string
      T              % true value, to go on with do...while loop
    ]                % end if               
  }                  % else                                                    
    T.               % unconditional break
  ]                  % end                                                     
]                    % end                                                     
x                    % delete original random value
— लुइस मेंडो
स्रोत
1

पर्ल 6 ,  58    53 बाइट्स

for ^6 .pick(*) {get;say <*BANG!* *click*>[?$_];!$_&&last} # 58 bytes

$ perl6 -pe '$///=^6 .pick;$_=$/--??"*click*"!!say("BANG!")&&last' # 52+1= 53 bytes

ट्रिगर को खींचने के लिए एंटर दबाएँ, या इसे नीचे रखने के लिए ctrl + c।

— ब्रैड गिल्बर्ट b2gills
स्रोत
1

पायथन 2, 88 84 बाइट्स

यह समाधान पहले से दिए गए अजगर 3 समाधानों से प्रेरित है। मैंने प्रिंट कोष्ठक को हटाने के लिए अजगर 2 को चुना भले ही यह इनपुट () के व्यवहार को बदलता है।

import time
for i in[0]*int(time.time()%6)+[1]:input();print("*click*","*BANG!*")[i]
  • मैं उस समय के मोडुलो का उपयोग एक यादृच्छिक कार्य (रूसी रूले के लिए पर्याप्त) के रूप में कर रहा हूं
  • खिलाड़ी इनपुट "i" होना चाहिए फिर एंटर (अन्यथा इनपुट) त्रुटि को फेंक देगा), यह ट्रिक इस तथ्य पर निर्भर करती है कि इनपुट "जो भी" हो सकता है।
— Basile-हेनरी
स्रोत
1

रूबी, 45 + 1 = 46

जितना होशियार नहीं डी-साइड के लेकिन थोड़ा छोटा है।

कमांड-लाइन ध्वज के साथ p, चलाएँ

rand(7-$.)<1?(puts'*BANG*';exit):$_='*click*'

उपयोगकर्ता नियंत्रण-सी के साथ वापसी और ट्रिगर के साथ ट्रिगर खींच सकता है। pप्रोग्राम को लूप में चलाने का कारण बनता है, STDIN से लाइनें पढ़ना और आउटपुट करना$_ । हर बार जब यह चलता है, तो यह बढ़ जाता है $.। तो पहले रन पर, यह 6 से कम यादृच्छिक यादृच्छिक पूर्णांक चुनता है, फिर 5, फिर 4 और इसी तरह। पहले 0 पर, हम मैन्युअल रूप से आउटपुट करते हैं और बाहर निकलते हैं, तब तक हम निहित रूप से आउटपुट करते हैं।

(और अब मुझे लगता है कि वहाँ पहले से ही एक बहुत ही पर्ल है। ठीक है।)

— histocrat
स्रोत
1

पर्ल 5, 69 51 49 बाइट्स

map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"

शायद कुछ और गोल्फिंग क्षमता है, मैं इस पर गौर करूंगा।

परिवर्तन:

  • हटाकर 8 बाइट्स बचाए $l और कुछ अर्धविराम, और 10 बाइट्स को बदलकर<STDIN> गया<>
  • 2 बाइट्स को ओलेग वी। वोल्कोव को धन्यवाद दिया
— ASCIIThenANSI
स्रोत
1
49:map{<>;print"*click*"}1..rand 6;<>;print"*BANG!*"
— ओलेग वी। वोल्कोव
@ ओलेगवी.वोलकोव धन्यवाद! मैं इसे अभी संपादित करूँगा।
— ASCIIThenANSI
0

VBA, 126 बाइट्स

न्यूनतम बाइट्स के लिए गोल्फ संस्करण

Sub S()
r=Int(5*Rnd())
e:
a=MsgBox("")
If a=1 Then: If i=r Then MsgBox "*BANG!*" Else: MsgBox "*click*": i=i+1: GoTo e
End Sub

मज़ेदार संस्करण जो बटनों को अधिक बढ़ाता है उपयोगकर्ता स्वीकृति के लिए अधिक स्पष्ट।

Sub RR()
r = Int(5 * Rnd())
e:
a = MsgBox("Are you Feeling Lucky?", 4)
If a=6 Then: If i=r Then MsgBox "*BANG!*", 16 Else: MsgBox "*click*", 48: i=i+1: GoTo e
End Sub

कस्टम फॉर्म के साथ कुछ मज़ेदार और आप VBA में एक बहुत अच्छा खेल बना सकते हैं।

— JimmyJazzx
स्रोत
0

एपीएल, 39/65 बाइट्स

{⍞⊢↑⍵:⍞←'*BANG*'⋄∇1↓⍵⊣⍞←'*click*'}6=6?6

बहुत सीधा सा जवाब।

— ओबेरोन
स्रोत
दो बाइट काउंट का क्या मतलब है?
— Mego
0

सी, 180 बाइट्स

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main(){srand(time(NULL));int r,i=6;while(i!=1){getchar();r=rand()%i;if(r){puts("CLICK");}else{puts("BANG");exit(0);}i--;}}

कोड गोल्फ में मेरा पहला प्रयास, सुधार के लिए शायद बहुत कुछ है :)

— रयान फिट्जपैट्रिक
स्रोत
0

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

b=rand(1:6);while b>0 readline();print(b>1?"*click*":"*BANG!*");b-=1end

Enterआग या Ctrl+ Cछोड़ने के लिए दबाएँ । उत्तरार्द्ध एक के साथ समाप्त होता है InterruptException।

Ungolfed:

# Set an initial bullet location
b = rand(1:6)

while b > 0
    # Read user input
    readline()

    # Check the location
    if b > 1
        print("*click*")
    else
        print("*BANG!*")
    end

    b -= 1
end
— एलेक्स ए।
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.