एक पोकर हाथ में अंतिम कार्ड चुनें

Question

पोकर हाथों को सबसे अच्छे से सबसे खराब स्थान पर रखा गया है:

1. सीधे फ्लश - अनुक्रमिक रैंक के पांच कार्ड, एक ही सूट के सभी
2. एक तरह के चार - एक ही रैंक के चार कार्ड और दूसरे रैंक के एक कार्ड
3. पूर्ण घर - एक रैंक के तीन कार्ड और दूसरे रैंक के दो कार्ड
4. फ्लश - एक ही सूट के सभी पाँच कार्ड
5. सीधे - अनुक्रमिक रैंक के पांच कार्ड
6. एक प्रकार के तीन - एक ही रैंक के तीन कार्ड और दो अन्य रैंक के दो कार्ड
7. दो जोड़ी - एक ही रैंक के दो कार्ड, दूसरी रैंक के दो कार्ड और तीसरी रैंक के एक कार्ड
8. एक जोड़ी - एक ही रैंक के दो कार्ड और तीन अन्य रैंक के तीन कार्ड
9. उच्च कार्ड - पांच कार्ड सभी क्रमिक रैंक या एक ही सूट के नहीं हैं, और इनमें से कोई भी समान रैंक का नहीं है

• रैंक = कार्ड पर संख्या (ए, के, क्यू, जे, 10, 9, 8, 7, 6, 5, 4, 3, 2)। आप 10 के बजाय T का उपयोग करना चुन सकते हैं।
• सूट = दिल (एच), हुकुम (एस), क्लब (सी) और हीरे (डी)।

ध्यान दें कि ऐस, Aदोनों उच्चतम और निम्नतम संख्या (1 या 14) हो सकती है।

एक कार्ड को दो अक्षरों As(हुकुम के ऐस), Jc(जैक ऑफ क्लब), 7h(7 दिलों) और इतने पर पहचाना जा सकता है ।

---

चुनौती:

आपको डीलर से चार कार्ड मिलते हैं (चार इनपुट स्ट्रिंग्स)। सबसे अच्छा संभव अंतिम कार्ड खोजें और आउटपुट करें।

यदि ऐसे कार्ड हैं जो समान रूप से अच्छे हैं तो आप चुन सकते हैं कि किसे चुनना है।

इनपुट और आउटपुट प्रारूप वैकल्पिक हैं, लेकिन व्यक्तिगत कार्ड को ऊपर दिखाए गए Jcऔर के रूप में पहचाना जाना चाहिए 2h।

---

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

Ah Kh Jh 10h
Qh

7d 8h 10c Jd
9d (or 9h, 9c, 9s)

Js 6c 10s 8h
Jc (or Jh, Jd)

Ac 4c 5d 3d
2h (or 2d, 2c, 2s)

5s 9s Js As
Ks

2h 3h 4h 5h
6h

Js Jc Ac Ah
As (or Ad)  <- Note that AAAJJ is better than AAJJJ because A is higher than J

10d 9d 5h 9c
9h (or 9s)

Ah Ac Ad As
Ks (or Kd, Kh, Kc)

4d 5h 8c Jd
Jc (or Js, Jh)

यह कोड गोल्फ है, इसलिए बाइट्स जीतने वाला सबसे छोटा सबमिशन है।

Answer 1

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

eo_S+*-5l@\AN}SPMJ+NZSM.:+\AT5+-4l{eMJlM.gPkJ-sM*=T+`M}2Tc4"JQKA""hscd"=Zc

यह बहुत भयानक है। कार्डों को पार्स करना, मूल्यों को क्रमबद्ध करना, ... सब कुछ बहुत सारे चार्ट लेता है। लेकिन दृष्टिकोण दिलचस्प है।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

मैं सभी 52 कार्ड उत्पन्न करता हूं, इनपुट के चार कार्ड निकालता हूं, प्रत्येक कार्ड (हाथ का स्कोर) के लिए एक अंक उत्पन्न करता हूं, और अधिकतम स्कोर के साथ कार्ड प्रिंट करता हूं।

स्कोर थोड़ा अजीब है। अगर मैं दो अलग-अलग हाथों के स्कोर की तुलना करता हूं, तो यह गलत विजेता को चुन सकता है। जैसे एक सीधा 4 इक्के मारता है। लेकिन यह काम करता है, अगर पहले 4 कार्ड दोनों हाथों में समान हैं। और मेरा गणना स्कोर वास्तव में एक मूल्य नहीं है, लेकिन मूल्यों की एक सूची है:

• जी: पहले मैं 5 कार्डों को रैंक करके समूह बनाता हूं और लंबाई लेता हूं: 5h 5d 6c 5s Jd -> [3, 1, 1]
• F: फिर मैं इस सूची में विभिन्न ऋणों की संख्या 4 घटा देता हूं। Flush -> 3जोड़ा जाता है,not flush -> 2/1/0 जाता है।
• S: एक और नंबर जोड़ें। 0अगर यह सीधा नहीं है, 4अगर यह सीधा है A2345, या 5अगर यह अधिक सीधा है।

4-7 नंबर की ये सूची घटते क्रम में क्रमबद्ध हो जाती है और अधिकतम मान वाली सूची चुन ली जाती है।

यह काम क्यों करता है? यहां आप सभी प्रकार के लिए संभव कॉन्फ़िगरेशन देखते हैं। संख्याओं के साथ पत्र, आपको बताता है कि यह संख्या किस नियम से उत्पन्न हुई है।

• सीधे फ्लश: [5S, 3F, 1G, 1G, 1G, 1G, 1G]या[4S, 3F, 1G, 1G, 1G, 1G, 1G]
• एक तरह के चार: [4G, 1G, 0F, 0S]
• पूरा घर: [3G, 2G, 1F, 0S]या[3G, 2G, 0F, 0S]
• फ्लश: [3F, 1G, 1G, 1G, 1G, 1G, 0S]
• सीधे: [5S, 2F, 1G, 1G, 1G, 1G, 1G], [5S, 1F, 1G, 1G, 1G, 1G, 1G], [5S, 1G, 1G, 1G, 1G, 1G, 0F], [4S, 2F, 1G, 1G, 1G, 1G, 1G], [4S, 1F, 1G, 1G, 1G, 1G, 1G],[4S, 1G, 1G, 1G, 1G, 1G, 0F]
• एक तरह के तीन: [3G, 1G, 1G, 1F, 0S],[3G, 1G, 1G, 0F, 0S]
• दो जोड़ी: [2G, 2G, 2F, 1G, 0S], [2G, 2G, 1F, 1G, 0S],[2G, 2G, 1G, 0F, 0S]
• एक जोड़ी: [2G, 2F, 1G, 1G, 1G, 0S], [2G, 1G, 1G, 1G, 1F, 0S],[2G, 1G, 1G, 1G, 0F, 0S]
• उच्च कार्ड: [2F, 1G, 1G, 1G, 1G, 1G, 0S], [1F, 1G, 1G, 1G, 1G, 1G, 0S],[1G, 1G, 1G, 1G, 1G, 0S, 0F]

पाइथ सूची-तत्व की तुलना करता है। तो यह स्पष्ट है कि स्ट्रेट फ्लश हमेशा एक तरह के फोर को हरा देगा। इन सूचियों के साथ अधिकांश विशिष्ट पोकर नियम स्पष्ट हैं। कुछ परस्पर विरोधी लगते हैं।

• एक स्ट्रेट चार या एक पूर्ण हाउस के खिलाफ जीतेगा: कोई समस्या नहीं है। यदि आपके पास नदी कार्ड के साथ एक तरह का चार / पूर्ण घर प्राप्त करने का मौका है, तो आप एक ही समय में सीधे नहीं पहुंच सकते हैं (क्योंकि आपके पास पहले से ही 2 या 3 अलग-अलग सूट आपके हाथ में हैं)।
• एक सीधा एक फ्लश के खिलाफ जीत जाएगा। यदि आप एक फ्लश और नदी कार्ड के साथ सीधे पहुंच सकते हैं, तो आप एक सीधी फ्लश तक भी पहुंच सकते हैं। और स्ट्रेट फ्लश में स्ट्रेट और फ्लश दोनों की तुलना में बेहतर स्कोर होता है।
• एक जोड़ा [2G, 2F, 1G, 1G, 1G, 0S] कुछ दो जोड़ी हाथों के खिलाफ जीतेगी। इसके अलावा कोई समस्या नहीं है। यदि आपको नदी कार्ड के साथ दो जोड़ी मिलती है, तो आपके पास नदी से पहले कम से कम एक जोड़ी थी। लेकिन इसका मतलब है, कि आप तीन तरह से सुधार कर सकते हैं, जो बेहतर है। तो एक दो जोड़ी वास्तव में कभी जवाब नहीं होगी।
• उच्च कार्ड [2F, 1G, 1G, 1G, 1G, 1G, 0S]कुछ एक जोड़ी हाथों के खिलाफ जीत जाएगा। यदि यह सबसे अच्छा स्कोर है, तो आप नदी तक पहुँचने से पहले आपके पास एक सुइट के 3 कार्ड और एक अलग सूट के एक कार्ड होंगे। लेकिन फिर आप इन दो सुइट्स में से एक के साथ कार्ड चुन सकते हैं और पहले से ही दिखाई देने वाले मूल्य के साथ, और आप स्कोर के साथ समाप्त हो जाएंगे [2F, 2G, ...], जो बेहतर भी है।

तो यह सही प्रकार का समाधान चुनता है। लेकिन मुझे सबसे अच्छी एक-जोड़ी (4 संभावनाओं में से) कैसे मिलती है, मैं सबसे अच्छा सीधे कैसे चुनूं, ...? क्योंकि दो अलग-अलग एक-जोड़ी समाधानों में समान स्कोर हो सकता है।

यह आसान है। Pyth स्थिर छँटाई (अधिकतम लेने पर) की गारंटी देता है। तो मैं सरल क्रम में कार्ड उत्पन्न करता हूं 2h 2s 2c 2d 3h 3s ... Ad। तो उच्चतम मूल्य वाला कार्ड स्वचालित रूप से अधिकतम होगा।

कार्यान्वयन का विवरण

=Zcइनपुट स्ट्रिंग को विभाजित करता है और इसमें कार्ड की सूची संग्रहीत करता है Z। =T+`M}2Tc4"JQKA"रैंकों की सूची तैयार करता है ['2', ..., '10', 'J', 'Q', 'K', 'A']और उन्हें स्टोर करता है T। -sM*T..."hscd"Zसुइट्स के साथ रैंक के प्रत्येक संयोजन को उत्पन्न करता है, और के कार्ड निकालता है Z।

o...इन शेष कार्डों का आदेश देता है: lM.gPkJरैंकों के समूहों का हिस्सा, +-4l{eMJlM4 - लंबाई (सूट) को +*-5l@\AN}SPMJ+NZSM.:+\AT5जोड़ता है , सूट के आधार पर 0/4/5 जोड़ता है (प्रत्येक "A" + T की लंबाई 5 की सबटाइटर उत्पन्न करता है, अगर हाथ की जाँच करें उनमें से एक (हाथ की छंटाई और सभी सबसेट को छांटने की आवश्यकता है), कार्ड में 5 - "ए" की संख्या से गुणा करें,_S सूची को कम कर दें।

e अधिकतम चुनें और प्रिंट करें।

Comments

बहुत रचनात्मक, और महान व्याख्या!

— ग्रेग मार्टिन

Answer 2

जावास्क्रिप्ट (ईएस 6), 329 324 317 312 309 बाइट्स

H=>[..."cdhs"].map(Y=>[...L="AKQJT98765432"].map(X=>~H.indexOf(X+=Y)||([...H,X].map(([R,S])=>a|=eval(S+'|=1<<L.search(R)',F|=S!=H[0][1]),F=a=c=d=h=s=0),x=c|d,y=h|s,c&=d,h&=s,p=c|x&y|h,t=c&y|h&x,(S=a-7681?((j=a/31)&-j)-j?F?c&h?2e4+a:t?t^p?3e4+t:7e4:p?8e4+p:M:4e4+a:F?5e4+a:a:F?6e4:1e4)<M&&(R=X,M=S))),M=1/0)&&R

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

डेक में प्रत्येक शेष कार्ड के लिए, हम एक हाथ स्कोर की गणना करते हैं S। स्कोर जितना कम होगा, हाथ उतना ही बेहतर होगा।

चर अंक की गणना करते थे

• F: अगर हाथ फ्लश है तो झूठा
• c: क्लबों के बिटमास्क
• d: हीरे का बिटकॉइन
• h: दिल का बिटकॉइन
• s: हुकुम के बिटमस्क
• x = c | d: क्लब या डायमंड्स के बिटमास्क
• y = h | s: दिल या हुकुम का बिटकॉस्म
• a: सभी संयुक्त सूट के बिटमास्क
• p = c & d | x & y | h & s: जोड़ी बिटमास्क ⁽¹⁾
• t = c & d & y | h & s & x: एक तरह के तीन बिटमास्क ⁽¹⁾

^(१) _{मैंने ये सूत्र कुछ साल पहले लिखे थे और कई पोकर इंजनों में इनका उपयोग किया था। वे काम करते हैं। :-)}

अन्य सूत्र

• c & d & h & s: एक प्रकार का चार बिटमास्क
• a == 7681: विशेष सीधे "ए, 2, 3, 4, 5" (0b1111000000001) के लिए परीक्षण करें
• ((j = a / 31) & -j) == j: अन्य सभी पट्टियों के लिए परीक्षण

स्कोर चार्ट

Value    | Hand
---------+--------------------------------------------
0   + a  | Standard Straight Flush
1e4      | Special Straight Flush "A, 2, 3, 4, 5"
2e4 + a  | Four of a Kind
3e4 + t  | Full House
4e4 + a  | Flush
5e4 + a  | Standard Straight
6e4      | Special Straight "A, 2, 3, 4, 5"
7e4      | Three of a Kind
8e4 + p  | Pair
Max.     | Everything else

NB: हम दो जोड़ी के बारे में परवाह नहीं है जो संभवतः हमारा सबसे अच्छा विकल्प नहीं हो सकता है। (यदि हमारे पास पहले से ही एक जोड़ी है, तो हम इसे तीन प्रकार में बदल सकते हैं। और यदि हमारे पास पहले से ही दो जोड़े हैं, तो हम उन्हें पूर्ण सदन में बदल सकते हैं।)

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

let f =

H=>[..."cdhs"].map(Y=>[...L="AKQJT98765432"].map(X=>~H.indexOf(X+=Y)||([...H,X].map(([R,S])=>a|=eval(S+'|=1<<L.search(R)',F|=S!=H[0][1]),F=a=c=d=h=s=0),x=c|d,y=h|s,c&=d,h&=s,p=c|x&y|h,t=c&y|h&x,(S=a-7681?((j=a/31)&-j)-j?F?c&h?2e4+a:t?t^p?3e4+t:7e4:p?8e4+p:M:4e4+a:F?5e4+a:a:F?6e4:1e4)<M&&(R=X,M=S))),M=1/0)&&R

console.log(f(["Ah", "Kh", "Jh", "Th"]));   // Qh
console.log(f(["7d", "8h", "Tc", "Jd"]));   // 9d (or 9h, 9c, 9s)
console.log(f(["Js", "6c", "Ts", "8h"]));   // Jc (or Jh, Jd)
console.log(f(["Ac", "4c", "5d", "3d"]));   // 2h (or 2d, 2c, 2s)
console.log(f(["5s", "9s", "Js", "As"]));   // Ks
console.log(f(["2h", "3h", "4h", "5h"]));   // 6h
console.log(f(["Js", "Jc", "Ac", "Ah"]));   // As (or Ad)
console.log(f(["Td", "9d", "5h", "9c"]));   // 9h (or 9s)
console.log(f(["Ah", "Ac", "Ad", "As"]));   // Ks (or Kd, Kh, Kc)
console.log(f(["4d", "5h", "8c", "Jd"]));   // Jc (or Js, Jh)

Answer 3

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

यह काफी भारी है और मुझे यकीन नहीं है कि यह सबसे अच्छा तरीका है। अभी भी थोड़ा गोल्फ शायद।

h=>(r='_23456789TJQKAT',R=x=>r.search(x[0]),M=i=>[...'hcds'].some(s=>h.indexOf(j=h[i][0]+s)<0)&&j,[u,v,w,y]=h.sort((a,b)=>R(a)-R(b)).map(x=>R(x)),[,,d,e,f,g,k]=[...new Set(h+h)].sort(),q=10-u-v-w,s=(z=y>12)&q>0?q:y-u<5&&u*5+q-y,d>r?z?'Kh':'Ah':f>r?M((e>r?v<w:u<v)+1):s?r[s]+g:k?M(3):r[13-z-(w>11)-(v>10)]+g)

कम गोल्फ वाला

h=>(
  // card rank, 1 to 13, 0 unused
  // fake rank 14 is T, to complete a straight JQKA?
  // as I always try to complete a straight going up
  r = '_23456789TJQKAT', 

  // R: rank a card
  R = x => r.search(x[0]),  

  // M: find a missing card (to complete a same-rank set like a poker)
  // look for a card with the same rank of the card at position i
  // but with a suit not present in the hand
  M = i => [...'hcds'].some(s => h.indexOf(j=h[i][0]+s) < 0) && j,
  h.sort((a, b) => R(a)-R(b) ), // sort hand by rank
  [u,v,w,y] = h.map(x=>R(x)),   // rank of cards 0..3 in u,v,w,y

  // Purpose: look for duplicate rank and/or duplicate suits
  // Put values and suits in d,e,f,g,k, with no duplicates and sorted
  // suits are lowercase and will be at right end
  [,,d,e,f,g,k] = [...new Set(h+h)].sort(),

  // Only if all ranks are different: find the missing value to get a straight
  // or 0 if a straight cannot be obtained
  // The first part manages the A before a 2
  q = 10-u-v-w, s = y>12&q>0 ? q : y - u < 5 && u * 5 + q - y,

  d > r // d is lowercase -> all cards have the same rank
    ? u < 13 ? 'Ah' : 'Kh' // add a K to a poker of A, else add an A
    : e > r // e is lowercase -> 2 distinct ranks
      ? M(v<w ? 2 : 1) // go for a poker or a full house
      : f > r // f is lowercase -> 3 distinct ranks, we have a pair
        ? M(u<v ? 2 : 1) // find the pair and go for 3 of a kind
        : s // all different ranks, could it become a straight?
          ? r[s] + g // if there is only a suit, it will be a flush straight too
          : k // if there are 2 or more different suits
            ? M(3) // go for a pair with the max rank
            : r[13-(y>12)-(w>11)-(v>10)]+g // flush, find the max missing card
)

परीक्षा

F=
h=>(r='_23456789TJQKAT',R=x=>r.search(x[0]),M=i=>[...'hcds'].some(s=>h.indexOf(j=h[i][0]+s)<0)&&j,[u,v,w,y]=h.sort((a,b)=>R(a)-R(b)).map(x=>R(x)),[,,d,e,f,g,k]=[...new Set(h+h)].sort(),q=10-u-v-w,s=(z=y>12)&q>0?q:y-u<5&&u*5+q-y,d>r?z?'Kh':'Ah':f>r?M((e>r?v<w:u<v)+1):s?r[s]+g:k?M(3):r[13-z-(w>11)-(v>10)]+g)

output=x=>O.textContent+=x+'\n'

;`Ah Kh Jh Th -> Qh
7d 8h Tc Jd -> 9d 9h 9c 9s
Js 6c Ts 8h -> Jc Jh Jd
Ac 4c 5d 3d -> 2h 2d 2c 2s
5s 9s Js As -> Ks
2h 3h 4h 5h -> 6h
Js Jc Ac Ah -> As Ad
Td 9d 5h 9c -> 9h 9s
Ah Ac Ad As -> Ks Kd Kh Kc
4d 5h 8c Jd -> Jc Js Jh`
.split('\n')
.forEach(s=>{
  var o = s.match(/\w+/g) // input and output
  var h = o.splice(0,4) // input in h, output in o
  var hs = h+''
  var r = F(h)
  var ok = o.some(x => x==r)
  
  output((ok?'OK ':'KO ')+ hs + ' -> ' + r)
})

<pre id=O></pre>

Comments

यह देखने के लिए मजेदार है कि हमारे दोनों दृष्टिकोण बहुत समान आकारों की ओर अभिसरण करते हैं। :-) प्रदर्शन बुद्धिमान, आप निश्चित रूप से तेज़ हैं, हालाँकि।

— अरनौल्ड

@Arnauld मैं कुछ और 4 बाइट्स शेव करने में कामयाब रहा। आपकी बारी

— edc65