लोड, डिफेंड और शूट का गेम स्कोर करें

Question

_{जब मैं एक बच्चा था, तो मैं इस खेल को बहुत खेलता था।}

नियम

दो खिलाड़ी हैं (चलो उन्हें ए और बी कहते हैं), और प्रत्येक खिलाड़ी बंदूक के रूप में अपने हाथों का उपयोग करता है। तीन संभावित कदम हैं:

1. अपनी बंदूक पर गोला बारूद लोड करने के लिए हाथ।

   प्रत्येक बंदूक खाली होने लगती है। लोडिंग से गोला-बारूद बढ़ता है।

2. शूट करने के लिए दूसरे खिलाड़ी की ओर इशारा करते हुए हाथ।

   इससे गोला-बारूद घटता है। शूटिंग के लिए आपके पास कम से कम एक बारूद होना चाहिए।

3. खुद को एक शॉट से बचाने के लिए क्रॉस किए गए हथियार।

दोनों खिलाड़ी साथ-साथ चलते हैं। यदि दोनों खिलाड़ी एक ही समय में शूट करते हैं, तो गोलियां एक-दूसरे से टकराती हैं और खेल जारी रहता है। खेल तब समाप्त होता है जब एक खिलाड़ी शूटिंग करता है जबकि दूसरा गोला बारूद लोड कर रहा होता है।

शूटिंग और खाली बंदूक को धोखा माना जाता है । यदि कोई खिलाड़ी धोखा देता है जबकि दूसरा कानूनी कार्रवाई करता है, तो धोखेबाज तुरंत हार जाता है। यदि दोनों खिलाड़ी एक ही समय में धोखा देते हैं, तो खेल जारी रहता है।

धोखा देने के प्रयासों में गोला-बारूद की कमी नहीं होती है, इसलिए यह कभी भी नकारात्मक नहीं हो सकता है।

चुनौती

खिलाड़ियों ए और बी द्वारा किए गए कदमों को देखते हुए, आउटपुट किस खिलाड़ी ने गेम जीता: 1खिलाड़ी ए के लिए, -1खिलाड़ी बी के लिए, और 0ड्रॉ के लिए। आप रिटर्न मानों के किसी भी अन्य ट्रिपल का उपयोग कर सकते हैं, लेकिन आपको अपने उत्तर में यह बताने की आवश्यकता है कि आप किन लोगों का उपयोग करते हैं।

खेल हो सकता है:

• सभी चालों को संसाधित किए बिना अंत;
• दिए गए चालों के साथ अंत नहीं है, और इस तरह इसे एक ड्रॉ माना जाता है।

इनपुट लिया जा सकता है:

• तार के रूप में
• पूर्णांक के सरणियों / सूचियों के रूप में
• किसी भी अन्य तरीके से जो इनपुट को पूर्व-संसाधित नहीं करता है

पूर्ण कार्यक्रम या कार्य की अनुमति। चूंकि यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब!

परीक्षण के मामलों

A: "123331123"
B: "131122332"
    -----^                Player B shoots player A and wins.

Output: -1

A: "111322213312"
B: "131332221133"
    -------^              Player B cheats and loses.

Output: 1

A: "1333211232221"
B: "1213211322221"
    ----------^^          Both players cheat at the same time. The game continues.

Output: 0

A: "12333213112222212"
B: "13122213312232211"
         |       || ^---- Player A shoots player B and wins.
         ^-------^^------ Both players cheat at the same time. The game continues.

Output: 1

Comments

संबंधित कोठ (दिलचस्प रूप से, मैंने कभी भी इस प्रकार का खेल नहीं खेला है; मुझे लगता है कि जुड़ा हुआ प्रश्न एक मित्र से प्रेरित था, जो था, लेकिन यह बहुत पहले था कि मुझे अब याद नहीं है)।

— दरवाज़े

Answer 1

जेली, 33 32 24 बाइट्स

Zæ%1.»0$+¥\>-‘żZḅ3Ff5,7Ḣ

यह प्रिंट 5 के बजाय -1 , और 7 के बजाय 1 । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

Zæ%1.»0$+¥\>-‘żZḅ3Ff5,7Ḣ  Main link. Argument: A (digit list array)

Z                         Zip; group corresponding digits.
 æ%1.                     Map the digits in (-1.5, 1.5].
                          This replaces [1, 2, 3] with [1, -1, 0].
          \               Cumulatively reduce the pairs by doing the following.
     »0$                    Take the maximum of the left value and 0, i.e., replace
                            a -1 with a 0.
        +¥                  Add the modified left value to the right value.
                          This computes the available ammo after each action. An
                          ammo of -1 indicates a cheating attempt.
           >-             Compare the results with -1.
             ‘            Increment. And unilateral cheating attempt is now [1, 2]
                          or [2, 1], where 1 signals the cheater and 2 the winner.
              żZ          Pair each result with the corr., original digits.
                ḅ3        Convert each pair from base 3 to integer.
                          This maps [1, 2] and [2, 1] to 5 and 7.
                  F       Flatten the resulting, nested list.
                   f5,7   Discard all but 5's and 7's.
                       Ḣ  Grab the first element (5 or 7).
                          If the list is empty, this returns 0.

Answer 2

पायथ, 48 46 49 47 बाइट्स

.xhfT|M.e,-FmgF.b/<dhkY2S2Q?}b_BS2-FbZ.b,NYCQ)0

यहाँ यह कोशिश करो!

2 4 बाइट बचाने के लिए @isaacg को धन्यवाद !

खिलाड़ी A की चालों की सूची के साथ 2-tuple के रूप में इनपुट लेता है और खिलाड़ी B की चालों को दूसरा बनाता है। आउटपुट चुनौती के रूप में ही है।

व्याख्या

संक्षिप्त अवलोकन

• पहले हम दोनों खिलाड़ियों की चाल को एक साथ जोड़ते हैं, इसलिए हमें 2-ट्यूपल्स की सूची मिलती है।
• फिर हम उन टुपल्स में से प्रत्येक को दूसरे 2-ट्यूपल के रूप में मैप करते हैं, [cheating win, fair win]जिसमें से -1, 0, 1प्रत्येक के लिए संभव मानों के साथ , यह इंगित करने के लिए कि क्या कोई खिलाड़ी इस बिंदु पर जीता है ( -1, 1) या यदि गेम चलता है ( 0)
• अब हमें केवल पहला टपल प्राप्त करने की आवश्यकता है जो कि नहीं है [0,0], और इसका पहला गैर-शून्य तत्व लें जो विजेता को इंगित करता है

कोड टूटना

.xhfT | Me, -FmgF.b / <dhkY2S2Q;} b_BS2-FbZ.b, NYCQ) 0 # Q = चाल सूचियों की सूची

                                      .b, NYCQ # जोड़ी दोनों इनपुट सूचियों के तत्व
       .e # जोड़े के साथ सूची पर नक्शा 
                                                 # b जोड़ा जा रहा है और k यह इंडेक्स है
            एम क्यू # प्रत्येक कदम सूची डी मानचित्र
               .b 2S2 # मैप पर [1,2], मैं इसका उपयोग नहीं कर सकता क्योंकि यह है
                                                 # भेड़ का बच्चा चर .e से एक के साथ संघर्ष करता है
                  <dhk # d [: k + 1]
                 इस सूची में 1 या 2 की / Y # गिनती होती है
          -F # (1s की गिनती) - (2s की गिनती), धोखा जीत का संकेत देता है
                           ;} b_BS2 # अगर b है (1,2) या (2,1)
                                  -Fb # अंतर लेना, निष्पक्ष जीत इंगित करता है
                                     Z # और 0, अभी तक कोई विजेता नहीं है
         , # जोड़ी उन 2 मूल्यों
     | एम # प्रत्येक परिणामी जोड़ी के लिए, पहले एक ले लो अगर
                                                 # इसका शून्य नहीं, अन्यथा दूसरा
   fT # सभी शून्य मानों को फ़िल्टर करें
.xh # पहला मान लेने की कोशिश करता है जो विजेता को इंगित करता है
                                             ) 0 # यदि सूची संभव नहीं है क्योंकि सूची खाली है
                                                 # आउटपुट शून्य एक ड्रा इंगित करने के लिए

Comments

m|Fdके रूप में ही है |M।

— 22

@isaacg धन्यवाद! मैं हमेशा यह भूल जाता हूं कि Mबिखरना भी अच्छा है Btw: लैंबडा वैरिएबल के विवाद के बारे में हमने जिस चैट में चर्चा की, वह मुझे यहां कई बाइट्स दे रही है: P

— डेंकर

,1 2के रूप में ही हैS2

— isaacg

मैंने एक और टेस्टकेस जोड़ा है;)

— हटा दिया

@isaacg फिर से धन्यवाद! पता नहीं मैं कैसे चूक गया।

— डेनकर

Answer 3

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

def f(A,B):
 x=y=0;c=[-1,1,0]
 for i in range(len(A)):
  a=A[i];b=B[i]
  for s in[0,1]:
   if(a,b)==(2,1):return c[s]*c[x<1]
   if(a,b)==(2,3)and x<1:return-c[s]
   x-=c[a-1];x+=x<0;a,b,x,y=b,a,y,x
 return 0

स्पष्टीकरण : पूर्णांक की सूची के रूप में ए और बी लेता है। बस जरूरत पड़ने पर प्रत्येक जोड़ी में चाल, जोड़ या घटाव 1 होता है और जब कोई धोखा देता है या जीत जाता है। लूप के लिए दूसरे का उपयोग करते हुए एक ही बार दो बार करता है, एक बार ए की चाल के लिए और एक बार बी की चाल के लिए। 1 जोड़ता है अगर x 0 से -1 के नीचे जाता है।

Answer 4

जावा, 226 212 200 196 194 बाइट्स

-14 तर्क को फिर से आदेश देकर बाइट्स

-12 बाइट्स मिस्टर पब्लिक का शुक्रिया अदा करना कि कैसे शूटिंग लॉजिक के लिए टर्नरी ऑपरेशन का इस्तेमाल करना है

-4 बाइट्स को एक छोटे से सर्कुलेटिंग में लोड लॉजिक को क्रैमिंग करके

-2 बाइट्स क्योंकि ==1=== <2जब इनपुट केवल हो सकता है 1, 2,3

(a,b)->{for(int m=0,n=0,w,v,r=0,i=0,x;i<a.length;){w=a[i];v=b[i++];x=w==2?m<1?r--:m--:0;x=v==2?n<1?r++:n--:0;if(r!=0)return r;if(w<2&&++m>0&v==2)return -1;if(v<2&&++n>0&w==2)return 1;}return 0;}

उपयोग और इंडेंटेड संस्करण:

static BiFunction<Integer[], Integer[], Integer> game = (a,b) -> {
    for(int m=0,n=0,w,v,r=0,i=0,x;i<a.length;) {
        w=a[i];v=b[i++];
        // shoot
        x=w==2?m<1?r--:m--:0;
        x=v==2?n<1?r++:n--:0;
        if(r!=0)return r;
        // load
        if(w<2&&++m>0&v==2)return -1;
        if(v<2&&++n>0&w==2)return 1;
    }
    return 0;
};

public static void main(String[] args) {
    System.out.println(game.apply(new Integer[] {1,2,3,3,3,1,1,2,3}, new Integer[] {1,3,1,1,2,2,3,3,2}));
    System.out.println(game.apply(new Integer[] {1,1,1,3,2,2,2,1,3,3,1,2}, new Integer[] {1,3,1,3,3,2,2,2,1,1,3,3}));
    System.out.println(game.apply(new Integer[] {1,3,3,3,2,1,1,2,3,2,2,2,1}, new Integer[] {1,2,1,3,2,1,1,3,2,2,2,2,1}));
}

अब खेल के नियमों का इतना सरल कार्यान्वयन नहीं है, लेकिन सरल है। प्रत्येक चक्र, ये ऑपरेशन करता है:

• लोड गति अस्थायी चर में
• अगर खिलाड़ी को गोली मार दी
  • बिना बारूद: पूर्वाग्रह rहारने की ओर धोखा देता है
  • बारूद के साथ: घटाव बारूद
• यदि धोखा rनहीं है 0, तो मान वापस करें क्योंकि किसी ने धोखा दिया है
• यदि खिलाड़ी पुनः लोड हो जाता है
  • वेतन वृद्धि बारूद
  • यदि अन्य खिलाड़ी ने गोली मारी, तो नुकसान हुआ

x कंपाइलर बनाने के लिए उपयोग किया जाने वाला डमी वैरिएबल है, जो मुझे टर्नरी एक्सप्रेशन का उपयोग करने देता है।

रुको, जावा पायथन की तुलना में SHORTER है?

Comments

मैंने एक और टेस्टकेस जोड़ा है;)

— हटा दिया

@AshingtonGuedes और मेरा इस मामले पर काम करता है मेरे तर्क के लिए धन्यवाद!

— सीएडी 97

क्या इफ्स को टर्नरी में बनाया जा सकता है? उदाw==2&&m<1?r--:m++

— डाउनगोट

@Downgoat अन्य भीतर से जाता है अगर ऐसा है तो आपने लिखा है कि यह तृतीयक काम नहीं करेगा। हालाँकि, मैं शायद भीतर के साथ ऐसा कर सकता हूँ अगर। मौका मिलने पर मैं इसका परीक्षण करूंगा।

— सीएडी 97

@ CAD97 @Downgoat आप वास्तव में इफ-स्टेटमेंट के लिए टर्नरी ऑपरेटर का उपयोग कर सकते हैं। पहले टर्नरी के लिए, int x=w==2?m<1?r--:r:m--;फिर x का उपयोग करना जारी रखें (क्योंकि यह टर्नरी को संचालित करने के लिए सिर्फ एक डमी वैरिएबल है) जैसेx=v==2?n<1?r++:r:n--;

— Mr Public