मुझे धोखा देने में मदद करें

Question

धोखा एक कार्ड गेम है जहाँ आप अपना हाथ छुड़ाने की कोशिश कर रहे हैं। एक मोड़ कुछ इस तरह दिखता है:

1. निर्धारित करें कि आपको उस रैंक को कौन सा कार्ड खेलना है। अधिकांश वेरिएंट में यह पिछले मोड़ से एक रैंक अधिक है।
2. 1-4 कार्ड खेलते हैं, नीचे का सामना करते हैं। इनका वैध रैंक से मिलान नहीं है। यदि वे नहीं करते हैं, तो यह एक धोखा माना जाता है । इस बिंदु पर कोई भी खिलाड़ी आपको चुनौती दे सकता है ।
   • अगर कोई आपको चुनौती नहीं देता है, तो अगले खिलाड़ी के लिए खेलना जारी रहता है।
   • अगर कोई आपको चुनौती देता है और आपने धोखा नहीं दिया, तो उन्हें सभी खेले गए कार्ड लेने होंगे।
   • अगर कोई आपको चुनौती देता है और आपने धोखा दिया है, तो आपको सभी खेले गए कार्ड लेने होंगे।

रणनीति ज्यादातर ब्लफ़िंग और कार्ड काउंटिंग का मिश्रण है। हालांकि, मैं गणित में बुरा हूं, इसलिए मैं चीट को धोखा देने जा रहा हूं और मेरे साथ एक बॉट ला रहा हूं।

इनपुट

इनपुट आपको किसी भी क्रम या प्रारूप में चाहिए:

1. खिलाड़ी का हाथ। अगर मुझे पता है कि उनके पास कार्ड होना चाहिए (उदाहरण के लिए, मैंने उन्हें उठाकर देखा है), तो उन्हें आरोही क्रम में सूचीबद्ध किया जाएगा। किसी भी अज्ञात को बाद में सूचीबद्ध किया जाएगा ?। उदाहरण के लिए, यदि उनके पास छह कार्ड हैं और मुझे पता है कि दो 1 हैं और एक 4 है, तो हाथ का एक वैध प्रतिनिधित्व है 114???। हमेशा ज्ञात कार्ड के बाद सूचीबद्ध किया जाएगा। 141???और 11???4दोनों अमान्य इनपुट हैं और आपके कोड को उन्हें संभालने की आवश्यकता नहीं है।
2. मुझे निश्चित रूप से पता है कि कार्ड उनके हाथ का हिस्सा नहीं हैं (मेरे पास हैं, मैंने देखा कि कोई और उन्हें उठा सकता है, आदि)। सूची रैंक के आरोही क्रम में होगी। सूची खाली हो सकती है।
3. जिस खिलाड़ी ने खेलने का दावा किया है। यदि वे 3 7 का खेल खेलने का दावा करते हैं, तो यहां एक संभावित इनपुट होगा 777। कार्ड हमेशा एक ही रैंक के होंगे।

खेले गए कार्डों की संख्या हमेशा 1-4 होगी और रैंक हमेशा 0-9 रहेगी। एक रैंक उनके हाथ में चार से अधिक बार कभी नहीं दिखाई देगी + उनके हाथ नहीं।

यह एक उदाहरण वैध इनपुट है:

33577??
01555688
55

यह एक उदाहरण अमान्य इनपुट है:

35377?? # Out of order
7779    # Five 7's in total
23      # Two separate ranks played

उत्पादन

एक सत्य मूल्य अगर हमें निश्चित रूप से चुनौती देनी चाहिए । यदि हम चुनौती नहीं देना चाहते तो एक गलत मूल्य।

हम हमेशा चुनौती देते हैं अगर हम जानते हैं कि उन्होंने धोखा दिया है। हम जानते हैं कि उन्होंने धोखा दिया अगर वे कार्ड खेलते थे तो वे संभवतः नहीं कर सकते थे:

12

3  # They don't have any 3's or ?'s    
-------------
12?

33 # Fewer ?'s than played cards
-------------
123?
333
33 # Since we have three 3's they can't have two

दूसरी बार जब हम चुनौती देते हैं अगर वे अपना आखिरी कार्ड खेलते हैं। यहां तक ​​कि अगर खेल के वैध होने के कारण यह खेल समाप्त हो जाएगा तो हम इसे चुनौती दे सकते हैं।

1

1 # They'd win, so challenge anyway

अधिक परीक्षण मामले

सत्य (चुनौती चाहिए)

11445678?

22
-------------
????????
4
4444
-------------
12345678

9

झूठी (चुनौती नहीं देनी चाहिए)

1?
222
2
-------------
12?
22
22
-------------
?????

1111

स्कोरिंग

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

Comments

यह

— बकवास है

कितने लोग खेल रहे हैं?

— जैक्सनसेक

@jacksonecac आप केवल एक ही नाटक देख रहे हैं, इसलिए आपको इस बारे में चिंता करने की ज़रूरत नहीं है कि कितने खिलाड़ी हैं।

— होवरकच

यह एक राजा का पहाड़ी

— चालन

क्या आपको दूसरे झूठे मामले में चुनौती नहीं देनी चाहिए?

— स्टीफन टीटीजी

Answer 1

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

!}zS+*hzhS,/Q\?-4l@z+w

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

Answer 2

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

(h,s,c,g=(a,z=c[0])=>a.split(z).length-1)=>h.length==g(c)|g(h,'?')+g(h)<g(c)|g(h)+g(s)+g(c)>4

कार्ड के तीन तारों को स्वीकार करता है (वर्ण 0- 9या ?); 1चुनौती के लिए रिटर्न , 0अन्यथा। स्पष्टीकरण:

(h,s,c,                 Input parameters
 g=(a,z=c[0])=>         Helper function defaults to claimed card
  a.split(z).length-1   Count cards matching (g(c) == c.length)
)=>h.length==g(c)       Does hand length equal claim length
  |g(h,'?')+g(h)<g(c)   Could hand not contain claimed cards
  |g(h)+g(s)+g(c)>4     Are there too many claimed cards

Answer 3

सी # 6, 134 बाइट्स

using System.Linq;
bool f(string a,string b,string c)=>a.Length==1|a.Count(x=>x==c[0]|x=='?')<c.Length|b.Count(x=>x==c[0])+c.Length>4;

(नोट: ओपी के उदाहरण के अनुसार, यह उत्तर गलत है, भले ही प्रतिद्वंद्वी के पास एक से अधिक कार्ड हों और वह अपना सारा हाथ बजा रहा हो। रणनीति के संदर्भ में यह सही होना चाहिए।)

स्पष्टीकरण:

a: खिलाड़ी का हाथ
b: कार्ड मुझे निश्चित रूप से पता है ...
c: कार्ड खेलने का दावा किया

Ungolfed:

bool f(string a, string b, string c) => 
    a.Length == 1                               // Last card played
    | a.Count(x => x == c[0] | x == '?' )       // Count no. of cards that surely/may match claimed cards
                                                // Assuming all claimed cards are the same, just compare with c[0]
        < c.Length                              // I'm sure you don't have that many cards...
    | b.Count(x => x == c[0]) + c.Length > 4;   // ... Or that there can't be that many cards in play

Comments

नहीं a.Length==1होना चाहिए a.Length==c.Length। आपको लगता है कि आपके नोट में ऐसा कुछ है, लेकिन मुझे नहीं पता कि आप किस ओपी के उदाहरण का उल्लेख कर रहे हैं, जिससे यह संभव हो जाता है कि अधिक कार्ड खेले जा रहे हैं, फिर विरोधी की राशि उनके हाथ में है।

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

Answer 4

जावा 8, 169 135 बाइट्स

(a,b,c)->{int C=c.length();char x=c.charAt(0);return a.length()==C|(a+0).split(x+"|\\?",-1).length<=C|5-(b+0).split(""+x,-1).length<C;}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

(a,b,c)->{            // Method with three String parameters and boolean return-type
  int C=c.length();   //  The amount of cards played by your opponent this turn
  char x=c.charAt(0); //  The card played by your opponent this turn
  return a.length()==C//  Return true if your opponent played his entire hand (final round)
    |(a+0).split(x+"|\\?",-1).length
                      //   Or the amount of the played card and '?' in your opponent's hand
      <=C             //   is smaller than the amount of cards played
    |5-(b+0).split(""+x,-1).length
                      //   Or if 4 minus the amount of the played card are part of the
                      //   cards you definitely know, 
     <C;              //   is smaller than the amount of cards played
}                     // End of method

नोट: स्ट्रिंग में (s+0).split("c",-1).length-1वर्ण cहोने के समय की मात्रा देता है s। तो ऊपर दिए गए स्पष्टीकरण में टिप्पणियाँ सही हैं, लेकिन कोड इसके कारण अलग लग सकता है। के (a+0).split(x+"|\\?",-1).length-1<Cलिए गोल्फ है (a+0).split(x+"|\\?",-1).length<=Cऔर करने के 4-(b+0).split(""+x,-1).length-1<Cलिए गोल्फ है 5-(b+0).split(""+x,-1).length<C।