जो एक हुकुम चाल जीतता है

Question

हुकुम के खेल में चार-कार्ड की चाल जीतने वाले को निर्धारित करने के लिए कोड लिखें । सबसे कम बाइट्स जीतता है।

इनपुट एक स्ट्रिंग है जो अनुक्रम में खेले गए चार कार्डों की सूची देता है जैसे TH QC JH 2H(टेन ऑफ़ हार्ट्स, क्वीन ऑफ़ क्लब, जैक ऑफ़ हार्ट्स, टू हार्ट ऑफ़)। एक कार्ड दो पात्रों द्वारा दिया जाता है: एक सूट से CDHSऔर एक मूल्य से 23456789TJQKA। आपको गारंटी दी जाती है कि इनपुट मान्य है और कार्ड अलग हैं।

आपको ट्रिक के विजेता के लिए नंबर 1, 2, 3 या 4 का आउटपुट देना चाहिए। उदाहरण में TH QC JH 2H, दिल का जैक चाल जीतता है, इसलिए आपको 3 आउटपुट चाहिए।

आपके इनपुट और आउटपुट बिल्कुल वर्णित होने चाहिए, सिवाय इसके कि नई रूपरेखाएँ वैकल्पिक हैं।

यहाँ एक चाल जीतने के लिए हुकुम नियम हैं। विजेता कार्ड चार में से सबसे अधिक कार्ड है, जिसमें कुछ कैविएट हैं। हुकुम ट्रम्प सूट है , इसलिए कोई भी कुदाल किसी भी गैर-कुदाल से फैलती है। खेला गया पहला कार्ड का सूट लीड सूट है , और उस सूट या हुकुम के केवल कार्ड चाल जीतने के लिए पात्र हैं। उसी सूट के कार्ड की तुलना उनके मूल्यों से की जाती है, जो बढ़ते क्रम में दिए गए हैं 23456789TJQKA।

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

TH QC JH 2H
3
KC 5S QS 9C
3
QD 2D TD 5D
1
9S 5D AD QS
4
3D 4C 3H JH
1
9S 4S TS JS
4
5H 9H 2C AD
2
5S 4C 3H QD
1
2H 2S KH AH
2

Answer 1

पायथ, 28 27 25 बाइट्स

J"KTAZ"hxcz)eo_XN+@z1JJcz

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट (पहले 4 चार्ट टेस्ट सूट निर्माण हैं)

@Isaacg को एक ट्रिक के लिए धन्यवाद, जिसने 2 वर्णों को बचाया।

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

हाथों 23456789TJQKAका मान पहले से लगभग छँटा हुआ है। मैं बदलने के लिए बस Tके साथ A, Kके साथ Tऔर Aसाथ Zसाथ है, जिसके परिणामस्वरूप 23456789AJQSZ।

सूट का क्रम CDHSवास्तव में सबसे महत्वपूर्ण नहीं है। Sसबसे शक्तिशाली सूट, जो पहले से ही अधिकतम मूल्य है। महत्वपूर्ण यह है कि पहले हाथ के सूट को दूसरा सबसे शक्तिशाली मूल्य दिया जाए। इसलिए मैं इस सूट का अनुवाद करता हूं K।

सभी हाथों को भी उल्टा पढ़ना पड़ता है, क्योंकि सूट मूल्य से अधिक शक्तिशाली होता है।

                           implicit: z = input string
J"KTAZ"                    J = "KTAZ"
             o         cz  orders the hands N of split(z) by:
              _              the reversed of 
               XN+@z1JJ      N, where the values z[1]+J are replaced by J
            e              last element (winning hand)
        xcz)               index of the winning hand in split(z)
       h                   + 1

Comments

मैं हार जाता हूं, अच्छी तरह से खेला जाता है: P

— orlp

मुझे नहीं लगता कि .eसामान इसके लायक है - oजैसा कि मैंने इसे चित्रित किया है उसका उपयोग करना 1 वर्ण छोटा है।

— isaacg

@isaacg आपका अधिकार। मजेदार बात यह है कि, 28 समाधान से पहले मेरे पास 27 .eसमाधान थे। लेकिन 27 समाधान एक के साथ समाप्त हो गए )और इसलिए 28 बाइट्स भी थे। :

— उफ

मैं एक तरह से एक और 2 पात्रों को बचाने के लिए के बारे में सोचा: से अनुवाद +@z1"KTA"करने के लिए "KTAZ", लेकिन इसके बजाय तार का उपयोग कर सीधे का उपयोग की J"KTAZ"शुरुआत में और +@z1Jकरने के लिए J।

— isaacg

@ आइसाकग बहुत चालाक। धन्यवाद। Btw। मैं Xवैकल्पिक के 3 तर्क बनाने के बारे में काफी समय से सोच रहा हूं (केवल अगर ए और बी तार हैं)। लेकिन मुझे वास्तव में यकीन नहीं है, अगर Xab)मूल्यांकन करना चाहिए Xab_b(उल्टे बी, सामान की तरह अच्छा होगा Xa"</\>") या Xab+tbhb(बी स्थानांतरित)। आपकी प्राथमिकता क्या है?

— जकुबे

Answer 2

CJam, 34 33 बाइट्स

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)

कलन विधि

तर्क सरल है। मेरे पास एक कस्टम प्रकार चल रहा है, जिसमें मैं पहले सूट का प्रतिनिधित्व करने वाले दूसरे चरित्र को प्राथमिकता देता हूं। इसमें, हुकुम को सर्वोच्च प्राथमिकता मिलती है और फिर पहले फेंके गए सुइट को। बाकी सब हैं -1। तब मैं की अदला-बदली के साथ पहली चरित्र पर तरह Tके साथ Aऔर Qसाथ Kशाब्दिक छंटाई के लिए।

कोड स्पष्टीकरण

सबसे पहले, आइए देखें कि कार्ड के अंकित मूल्यों का शाब्दिक क्रम क्या है:

"23456789TJQKA"$

23456789AJKQT

इसलिए, सभी नंबर सही स्थिति में हैं। Jसही स्थिति में भी है। हम स्वैप करने की जरूरत है Kऔर QऔरJ और Aशाब्दिक आदेश प्राप्त करने के लिए।

lS/_{)2$0='S+\#\"TQKA"_$er+}$W>#)
lS/                                 "Read an input line and split on spaces";
   _{                      }$       "Copy the array and sort it using this custom logic";
     )                              "Take off the last character of each hand.";
      2$0=                          "Get the suit of the first hand";
          'S+                       "Add Spades suit to it";
             \#                     "Get the index of the current hand suit.
                                     1 for Spades, 0 for first hand suit, -1 otherwise";
               \                    "Put face value of this hand on top of stack";
                "TQKA"              "Put string TQKA on stack";
                      _$            "Copy and sort. This essentially reverses the string
                                     TQKA to form AKQT. This is 1 byte shorter than _W%";
                        er+         "Swap T with A and K with Q and add to the
                                     suit index calculated previously";
                                    "After the above tuple, sorting will automatically
                                     convert the tuple to string and sort lexically";
                             W>     "Get the array containing only the last element";
                               #)   "Get the index of this hand in original set and
                                     increment to convert it to 1 based";

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

Answer 3

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

सूची को स्कैन करें और पाए गए उच्चतम मूल्य की स्थिति वापस करें।

परीक्षण करने के लिए स्निपेट चलाएँ (फ़ायरफ़ॉक्स में)

F=t=>t.split(' ').map((c,i)=>(n='23456789TJQKA'.search(c[0])+(c[1]>'H'?40:c[1]==t[1]&&20))>m&&(m=n,r=i+1),m=0)|r

C.innerHTML=['TH QC JH 2H','KC 5S QS 9C','QD 2D TD 5D','9S 5D AD QS','3D 4C 3H JH','9S 4S TS JS','5H 9H 2C AD','5S 4C 3H QD'].map(h=>h+' -> '+F(h)).join('\n')

<pre id=C></pre>

Answer 4

पर्ल, 73 बाइट्स

#!perl -pl
/\B./;s/$&/P/g;y/TKA/IRT/;$_=reverse;@a=sort split;/$a[-1]/;$_=4-"@-"/3

मुझे आजमाओ ।

कार्ड के नामों को रूपांतरित करता है, इसलिए खेल मूल्य क्रम वर्णमाला क्रम का अनुसरण करता है, फिर छँटाई द्वारा उच्चतम उठाता है और स्थिति के लिए मूल स्ट्रिंग में देखता है।

Answer 5

रूबी, ५ ९ + २ = ६१

कमांड-लाइन झंडे के साथ na, भागो

p (1..4).max_by{|i|$F[i-1].tr($_[1]+'SJQKA','a-z').reverse}

Answer 6

जे, 47 बाइट्स

1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{

उपयोग:

   (1+[:(i.>./)_3+/\16!@-]i.~'SXAKQJT9876543'1}~1&{) 'TH QC 9S 8S'
3

तरीका:

• प्रत्येक इनपुट चार के लिए हम 'S[second char of input]AKQJT9876543'स्ट्रिंग में इसकी स्थिति के आधार पर एक मूल्य प्रदान करते हैं । गैर-पाया वर्णों को अनुमानित last position + 1रूप से मूल्य मिलता है । आगे के पात्रों का मूल्य बहुत कम है ( value=(16-position)!)।
• 3 इनपुट-चार त्रिक और एक द्वैध (जैसे TH_ QC_ 9S_और 8S) के लिए योग की गणना करें ।
• अधिकतम मूल्य का 1-आधारित सूचकांक चुनें।

(जे दुर्भाग्य से सीधे वर्ण या तार की तुलना नहीं कर सकते। यह केवल उनकी समानता के लिए जांच कर सकता है जिसने इस चुनौती के लिए कुछ अन्य दृष्टिकोणों को खारिज कर दिया है।)

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

Answer 7

सी #, 237

using System;namespace S{class P{static void Main(string[] a){var V="23456789TJQKA";int x=0;int y=0;var z=a[0][1];for(int i=0;i<4;i++){int q=V.IndexOf(a[i][0])+2;var w=a[i][1];q*=w==z?1:w=='S'?9:0;if(q>y){x=i;y=q;}}Console.Write(x+1);}}}

यह कैसे काम करता है: कार्ड के "मूल्य" की गणना करने के लिए प्रत्येक हाथ को अलग करें .. उच्चतम मूल्य सूचकांक को स्टोर करें। एक कार्ड का मूल्य कार्ड के रैंक के रूप में 0 से गुणा किया जाता है यदि यह एक कुदाल या उद्घाटन सूट नहीं है, 1 यदि यह उद्घाटन सूट है और 9 अगर यह एक कुदाल है लेकिन उद्घाटन सूट नहीं है। (9 चुना b / c 2 * 9 = 18> A = 14 और 9 एक एकल वर्ण है)

Answer 8

पायथ, 36 33 बाइट्स

KczdhxKeo,x,ehK\SeNXhN"TKA""AYZ"K

काफी सरल दृष्टिकोण, एक कस्टम कुंजी फ़ंक्शन के साथ छँटाई का उपयोग करता है, फिर उच्चतम मूल्य का सूचकांक पाता है।

Comments

क्या आपने सॉर्ट से बचने की कोशिश की और सिर्फ उच्चतम मूल्य पाया? जावास्क्रिप्ट में जो छोटा हो गया

— edc65

@ edc65 Pyth में उच्चतम मूल्य खोजने के लिए कोई ऑपरेशन नहीं है, बस सॉर्ट करने के लिए। लेकिन एक चरित्र ( e) के साथ आप अंतिम तत्व प्राप्त कर सकते हैं, इसलिए उच्चतम मान प्राप्त करना अंतिम तत्व प्राप्त करने के बाद छंटनी है।

— orlp

डाउनवॉटर, समझाने की परवाह?

— orlp

Answer 9

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

hxczdeo}\SNo}@z1Zox"TJQKA"hNScz

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

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

इस प्रक्रिया को पढ़ने का उचित तरीका सामने है। प्रक्रिया वांछित कार्ड को सूची के अंत तक सॉर्ट करती है, फिर इसे बाहर खींचती है और मूल सूची में इसका सूचकांक ढूंढती है।

• cz: यह कार्ड स्ट्रिंग्स की सूची तैयार करता है। c, काट, आम तौर पर एक बाइनरी फ़ंक्शन (arity 2) है, लेकिन जब केवल एक इनपुट पर कॉल किया जाता है, तो .split()स्ट्रिंग विधि के रूप में कार्य करता है ।

• S: यह सामान्य सॉर्टिंग व्यवहार को लागू करता है, जो उच्च संख्या से पहले कम संख्या वाले कार्ड को सॉर्ट करता है।

• ox"TJQKA"hN: यह कार्ड के पहले अक्षर के xस्ट्रिंग ( ) में इंडेक्स ( ) के द्वारा कार्ड्स का आदेश देता है । संख्याओं वाले कार्ड के लिए, पहला पत्र नहीं मिला है, जो परिणाम दे रहा है । चूंकि पायथ का छँटाई कार्य स्थिर है, गिने कार्ड का क्रम प्रभावित नहीं होता है।"TJQKA"hN-1

• o}@z1Z: अगला हम आदेश देते हैं कि क्या पहले कार्ड का सूट खेला गया है ( @z1) प्रश्न में कार्ड में है। चूंकि यह Trueपीछे की ओर है False, यह लीड सूट के कार्ड को पीछे भेज देता है।

• o}\SN: यह पहले के प्रकार के समान है, लेकिन यह इस बात पर निर्भर करता है कि पत्र Sकार्ड में है या नहीं, पीठ पर हुकुम भेज रहा है।

• hxczde: यह अंतिम कार्ड को इस तरह से निकाला जाता है ( ), वांछित सूची को स्थान देते हुए, eकार्ड ( xczd) और 1 (वेतन वृद्धि) की सूची में अपना सूचकांक पाता है h।