परिचय

स्काट 3 खिलाड़ियों के लिए एक पारंपरिक जर्मन कार्ड गेम है। डेक में 32 कार्ड होते हैं: ऐस, किंग, क्वीन, जैक, 10, 9, 8, 7 इन 4 सूट (क्लब, हुकुम, दिल, हीरे)।

हर दौर में एक खिलाड़ी एकल खेलता है जबकि अन्य दो उसके खिलाफ खेलते हैं। एक दौर की शुरुआत में प्रत्येक खिलाड़ी को 10 कार्ड दिए जाते हैं, शेष 2 कार्ड को स्केट कहा जाता है और उन्हें बीच में लगा दिया । एकल खिलाड़ी एक बोली चरण द्वारा निर्धारित किया जाता है। यह गेम का हिस्सा है जिसे आपको इस चुनौती से निपटना होगा, इसके बारे में अधिक जानकारी नीचे दी गई है।

जो खिलाड़ी बोली चरण जीतता है वह एकल खिलाड़ी बन जाता है। वह स्काट उठाता है और फिर दो कार्ड छोड़ता है (जो समान हो सकता है, दूसरी टीम को पता नहीं है), ट्रम्प सूट उठाता है, और गोल शुरू होता है।

एक दौर में दस तरकीबें होती हैं। एक चाल जीतने वाला खिलाड़ी अगले एक को ले जाता है जब तक कि सभी कार्ड नहीं खेले जाते। मैं यहां नियमों की व्याख्या नहीं करूंगा, लेकिन आपको पता होना चाहिए कि बहुत सारे ट्रम्प कार्ड होना अच्छा है। यदि आप नियमों के बारे में सीखना चाहते हैं तो विकिपीडिया लेख देखें जो मैंने इस पोस्ट के शुरू में जोड़ा था, लेकिन इस चुनौती के लिए इसकी आवश्यकता नहीं है।

चुनौती

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

खेल मूल्य की गणना

हर हाथ का एक निश्चित खेल मूल्य होता है। यह आपके पास अनुक्रमिक जैक की मात्रा और सूट जिसे आप ट्रम्प के रूप में चुनना चाहते हैं, द्वारा निर्धारित किया जाता है। चलो पहले कारक के साथ शुरू करते हैं, जैक!

द जैक फैक्टर

जैक हमेशा ट्रम्प कार्ड होते हैं, और वे हर दूसरे ट्रम्प कार्ड को हरा देते हैं। चार जैक के बीच शक्ति का क्रम है:

क्लब ऑफ जैक (उच्चतम)
हुकुम का जैक
जैक ऑफ हार्ट्स
जैक ऑफ डायमंड्स (सबसे कम)

आगे की व्याख्या में मैं उन्हें उन संख्याओं के साथ संदर्भित करूँगा जो मैंने उन्हें यहाँ सौंपे थे।

आपको याद है कि कुछ प्रकार का कारक है जो आपको जैक से मिलता है जो कि खेल के मूल्य का हिस्सा है? महान! यहाँ आप इसे कैसे प्राप्त करें:

यह जैक फैक्टर अनुक्रम में शीर्ष जैक की संख्या (ऊपर क्रम देखें), प्लस 1 है। इसलिए यदि आपके पास सभी 4 जैक हैं तो यह 4 + 1 = 5. है। यदि आपके पास केवल पहले 2 जैक हैं, तो यह 2 + 1 = है 3।

वैकल्पिक रूप से, चीजों को थोड़ा और अधिक जटिल बनाने के लिए, जैक फैक्टर क्रम में शीर्ष जैक की संख्या भी हो सकती है जो आप गायब हैं , प्लस 1। इसलिए यदि आप पहले वाले को याद कर रहे हैं, तो यह 1 + 1 = 2. है। यदि आप वह पहले 3 को याद कर रहा है, यह 3 + 1 = 4 है। ऊपर दिए गए नंबर का उपयोग करते हुए यहां कुछ उदाहरण दिए गए हैं:

[1, 4] -> 1 + 1 = 2
[1, 2, 4] -> 2 + 1 = 3
[2, 3, 4] -> 1 + 1 = 2
[1, 2, 3, 4] -> 4 + 1 = 5
[] -> 4 + 1 = 5

वह पहला कारक था। यहां बताया गया है कि आपको दूसरा कैसे मिलेगा:

ट्रम्प सूट कारक

यह एक बहुत सरल है। दूसरा कारक ट्रम्प सूट द्वारा निर्धारित किया जाता है जो एकल खिलाड़ी निम्नलिखित मैपिंग का उपयोग करता है:

Clubs    -> 12
Spades   -> 11
Hearts   -> 10
Diamonds ->  9

यह आसान था, है ना?

खेल मूल्य

खेल का मूल्य दो कारकों का उत्पाद है। बहुत आसान है आपको लगता है? गलत! जबकि जैक-फैक्टर तय है, सूट-फैक्टर नहीं है। ट्रम्प के रूप में आपके द्वारा चुना गया सूट ट्रम्प की मात्रा और आपके हाथ में आपके गैर-ट्रम्प कार्ड के मूल्य पर निर्भर करता है। यह समझाने के लिए बहुत जटिल होगा कि एक अच्छा हाथ कैसा दिखता है, इसलिए आप निम्न एल्गोरिथम का उपयोग करेंगे:

कौन सा-ट्रम्प-डू-आई-पिक एल्गोरिदम

आपको बोली में भाग लेने की आवश्यकता नहीं है। यदि आप तय करते हैं कि एकल खेलने के लिए आपका हाथ बहुत खराब है, तो आप बस पास कर सकते हैं। आपके हाथ को खेलने योग्य होने के लिए निम्नलिखित मानदंडों से मेल खाना चाहिए:

कम से कम 6 ट्रम्प कार्ड (ट्रम्प सूट के कार्ड + जैक की संख्या) लें। यदि यह एक से अधिक सूट के लिए संभव है, तो वह चुनें, जिसके परिणामस्वरूप अधिक ट्रम्प कार्ड होंगे। यदि अभी भी एक टाई है, तो ऊपर दी गई उच्चतम रेटिंग के साथ सूट चुनें।
गैर-ट्रम्प कार्ड में से, कम से कम 1 ऐस है।

यदि आपका हाथ इस मापदंड के दोनों से मेल नहीं खाता है, तो आप पास हो जाएंगे। यदि ऐसा होता है, तो आप गणना किए गए खेल मूल्य और चुने हुए ट्रम्प सूट का उत्पादन करेंगे।

संक्षिप्त नोट: बेशक यह एक बहुत ही सरल एल्गोरिथ्म है। इस तरह से एक चुनौती का सामना करने में एक हाथ से निर्णय लेने में बहुत अधिक रणनीति और अनुभव होता है।

इनपुट

हर कार्ड में एक विशिष्ट पहचानकर्ता होता है। पहला भाग सूट ( C lubs, S pades, H earts, D iamonds) है, दूसरा भाग वह मूल्य है जो इस मैपिंग द्वारा दिया गया है:

Ace -> A
King -> K
Queen -> Q
Jack -> J
10 -> 0
9 -> 9
8 -> 8
7 -> 7

दोनों भागों ने मिलकर एक कार्ड बनाया। मान पहले आता है, फिर सूट आता है। आप अपनी इच्छानुसार किसी भी प्रारूप में कार्ड ले सकते हैं।

उत्पादन

यदि हाथ खेलने योग्य है, तो खेल मूल्य और चुना हुआ ट्रम्प सूट (ऑर्डर कोई फर्क नहीं पड़ता) को आउटपुट करता है। यदि यह नहीं है, तो आउटपुट "पास"।

नियम

जैसा कि उल्लेख किया गया है कि आप इनपुट को आपके लिए सबसे सुविधाजनक प्रारूप में ले सकते हैं। उदाहरण परीक्षण मामलों में नीचे देखते हैं।
इनपुट कमांड लाइन तर्कों, उपयोगकर्ता इनपुट, या फ़ंक्शन तर्कों द्वारा प्रदान किया जा सकता है।
आउटपुट रिटर्न वैल्यू के रूप में प्रदान किया जा सकता है या बस स्क्रीन पर मुद्रित किया जा सकता है।
इनपुट में कार्ड किसी भी तरह से ऑर्डर नहीं किए जा सकते हैं। आपका प्रोग्राम किसी भी यादृच्छिक कार्ड क्रम से निपटने में सक्षम होना चाहिए।
सबसे कम बाइट-काउंट जीत!

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

परीक्षण मामलों में इनपुट 2-चार स्ट्रिंग्स की एक सूची होगी।

1. ["JC", "JS", "JD", "AC", "KC", "9C", "AS", "7H", "QD", "8D"] -> 36 Clubs
2. ["JD", "AS", "0S", "KS", "QS", "9S", "8S", "AD", "8C", "9C"] -> 44 Spades
3. ["JH", "JD", "0S", "KS", "9C", "8C", "QH", "KH", "AD", "9D"] -> pass
4. ["JD", "AS", "KS", "QS", "0S", "9S", "8D", "7D", "0C", "QH"] -> pass

स्पष्टीकरण:

ट्रम्प के रूप में क्लब के साथ एक पंक्ति में दो जैक। तो खेल मूल्य 3 x 12 = 36 है
ट्रम्प के रूप में हुकुम के साथ गायब एक पंक्ति में तीन जैक। तो खेल मूल्य 4 x 11 = 44 है
केवल ट्रम्प कार्ड की अधिकतम 4 संभव है, इसलिए आप पास होंगे।
हुकुम के साथ छह ट्रम्प कार्ड लेकिन कोई गैर-ट्रम्प इक्का नहीं है, इसलिए आप पास होंगे।

यदि कुछ नियम अस्पष्ट हैं, तो आगे बढ़ें और टिप्पणी करें। मैं इस खेल के साथ बड़ा हुआ हूं, इसलिए मेरे लिए न्याय करना मुश्किल है अगर मैंने पर्याप्त विस्तार से सब कुछ बताया।

और अब ... हैप्पी कोडिंग!

संपादित करें: जैसा कि टिप्पणियों में मुझे बताया गया है (isaacg के लिए धन्यवाद), एक नियम है जो 4 जैक के बाद "जैक-फैक्टर" में निम्नलिखित शीर्ष ट्रंप को गिना जाता है, इसलिए यह 11. तक जा सकता है। इस चुनौती को सरल बनाए रखने के लिए और लोगों को भ्रमित न करने के लिए, मेरे द्वारा प्रस्तावित नियम मूल रूप से वही रहेंगे जो वे हैं। तो अधिकतम कारक 5 पर रहता है।

code-golf card-games

— Denker
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है - उत्कृष्ट पहली चुनौती! :)

— दरवाज़े

क्या सीधे जैक / लापता जैक की संख्या में भी शीर्ष सूट ट्रंप क्रम में शामिल होना चाहिए? यहाँ

— isaacg

@ आईसैक मुझे स्वीकार करना होगा कि मुझे अब तक इस नियम के बारे में पता नहीं था। यह बात बताने के लिए धन्यवाद। मैंने कुछ शोध किया और आप वास्तव में सही हैं। मेरे परिवार में हम इस नियम से नहीं खेलते हैं और मैं किसी ऐसे व्यक्ति से नहीं मिला हूं जो इसके साथ खेलता हो। इसमें वह उच्च प्रासंगिकता नहीं है, क्योंकि जब आपके पास ऐसा हाथ होता है, तो आप ज्यादातर बार ग्रैंड खेलेंगे जो कि वैसे भी अलग-अलग गिना जाता है। इसलिए इस चुनौती के लिए हम सिर्फ मेरे द्वारा प्रस्तावित नियमों के साथ बने रहेंगे। मैं अपनी पोस्ट को संपादित करूंगा ताकि यह सभी के लिए स्पष्ट हो।

— डेनकर १

@DenkerAffe, मैंने जर्मनी के एक क्लब में कई वर्षों तक स्काट खेला और मुझ पर विश्वास किया, नियम महत्वपूर्ण है, और ऐसे मामले हैं जहां यह अत्यंत प्रासंगिक है (और हाँ, यह अधिकांश गैर-गंभीर खिलाड़ियों में अज्ञात है)। विशेष रूप से लापता पक्ष के साथ - कल्पना करें कि आपके पास अन्य रंगों में के, डी, 9, 8, 7, और तीन ए और दो 10 हैं। आपके ग्रैंड निश्चित रूप से मर जाते हैं, लेकिन आप 'ओने 6' (कुछ संक्रमण इकट्ठा कर सकते हैं) खेल सकते हैं, और उन्हें हरा सकते हैं, यह मानते हुए कि आपको अंदाजा है कि बी कैसे बोली से बैठे हैं। और आप तब तक बोली लगा सकते हैं जब तक सूरज उस कार्ड के साथ नहीं आता।

— अगंजु

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

— डेनकर

पायथन 2, उदाहरण कार्यान्वयन

चूंकि अभी तक कोई प्रस्तुतियाँ नहीं हैं, इसलिए मैंने पायथन में एक उदाहरण कार्यान्वयन लिखा। इनपुट प्रारूप चुनौती में टेस्टेसिस के समान है।

हो सकता है कि आप लोगों को जाने के लिए प्रेरित करें, यह इतना कठिन नहीं है :)

def gameValue(hand):
    jacks = ""
    suits = {"C" : 0, "S" : 0, "H" : 0, "D" : 0}
    # Loop through the hand, find all jacks and count the cards of each suit
    for card in hand:
        jacks += card[1] if "J" in card else ""
        suits[card[1]] += 1 if card[0] != "J" else 0

    # Map the Jacks to numbers while 1 is the highest (Clubs) then sort them ascending
    jacks =  sorted(map(lambda j: {"C" : 1, "S" : 2, "H" : 3, "D" : 4}[j], list(jacks)))

    # Sort the suits by amount. Highest amount and value is first after that
    suits = sorted(suits.items(), key = lambda suit: suit[1], reverse = True)
    trumpSuit = suits[0][0];
    # Amount of trumps is jack-count plus trumpsuit-count
    trumpCount = len(jacks) + suits[0][1];

    # Check for at least one ace that is no trump
    hasAce  = len(filter(lambda c: c[0] == "A" and c[1] != trumpSuit, hand)) >= 1

    # If the hand  is playable, calculate jack-factor and output the result, otherwise pass
    if trumpCount >= 6 and hasAce:
        # If there no jacks the factor is 5. If there are, find the first gap
        if len(jacks) > 0:
            lastJack = 0
            for jack in jacks:
                if jack - lastJack >= 2:
                    break
                lastJack = jack

            jackFactor = jacks[0] if lastJack == 0 else lastJack + 1
        else:
            jackFactor = 5

        trumpFactor = {"C" : 12, "S" : 11, "H" : 10, "D" : 9}[suits[0][0]]
        print str(trumpFactor * jackFactor) + " " + {12 : "Clubs", 11 : "Spades", 10 : "Hearts", 9 : "Diamonds"}[trumpFactor]
    else:
        print "pass"

— Denker
स्रोत

जावा, 256 बाइट्स

h->{int i,j=1,m=0,t,n=0,a[]=new int[8];for(var c:h){t=c[1]-48;if(c[0]==74){j+=1<<t;n++;}else{m+=i=c[0]==65?1:0;a[--t+4]+=i;a[t]++;}}for(i=t=0;i<4;i++)t=a[i]<a[t]?t:i;return a[t]+n<6|m-a[t+4]<1?"p":(t+++9)*(5-(int)(Math.log(j>7?~j&7:j)/Math.log(2)))+" "+t;}

प्रारूप में चरित्र सरणियों की एक सरणी के रूप में इनपुट लेता है A4, जहां 4है क्लब , 3है हुकुम , 2है दिल और 1है हीरे । आउटपुट 36 4ट्रम्प सूट क्लब के साथ 36 की बोली के pलिए है , पास करने के लिए।

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

Ungolfed संस्करण:

h -> { // lambda taking a char[][] as argument and returning a String
    int i,                // used as a loop variable and as a temporary variable
        j = 1,            // variable storing the jacks present in the hand in its four last-to-least significant bits
        m = 0,            // number of aces in the hand
        t,                // used as a temporary variable at first, later stores the trump suit
        n = 0,            // number of jacks in the hand
        a[] = new int[8]; // in the lower 4 indices, stores the number of non-jack cards present in the hand for each suit; in the higher 4 indices, stores the number of aces present in the hand for each suit (0 or 1)

    for(var c : h) {   // loop over all the cards in the hand
        t = c[1] - 48; // determine the suit of the current card; 48 is the ASCII code for '0'
        if(c[0] == 74) { // if it's a jack; 74 is the ASCII code for 'J'
            j += 1 << t; // set the corresponding bit
            n++;         // and increment the total number of jacks
        } else {                             // if it's not a jack
            m += (i = (c[0] == 65 ? 1 : 0)); // increment the total number of aces if it's an ace (65 is the ASCII code for 'A')
            a[ --t + 4] += i;                // increment the number of aces for this suit if it's an ace
            a[t]++;                          // increment the number of non-jack cards for this suit
        }
    }

    for(i = t = 0; i < 4; i++)     // loop over the suits ...
        t = (a[i] < a[t]) ? t : i; // ... and find the one with the most cards, giving priority to higher-valued suits in case of a tie

    return (a[t] + n < 6) |                                             // if there are less than 6 trump cards
           (m - a[t + 4] < 1) ?                                         // or less than 1 non-trump ace
           "p"                                                          // return "p" to pass on the hand
           :                                                            // else return
           ((t++ + 9) *                                                 // the value of the trump suit (and increment the trump suit for output later)
           (5 - (int) (Math.log((j > 7) ? (~j & 7) : j) / Math.log(2))) // times the jack factor
           + " " + t);                                                  // followed by the trump suit
}

— OOBalance
स्रोत

सी, 235 बाइट्स

f(char*h){int i,j=1,m=0,t,n=0,a[8]={0};for(;*h;h+=2){t=h[1]-48;if(*h-74){m+=i=*h==65;a[--t+4]+=i;a[t]++;}else{j+=1<<t;n++;}}for(i=t=0;i<4;i++)t=a[i]<a[t]?t:i;printf(a[t]+n<6|m-a[t+4]<1?"p":"%d %d",(t+9)*(5-(int)log2(j>7?~j&7:j)),t+1);}

मेरे जावा उत्तर का पोर्ट ।