पोकर हाथ को नाम दें

22

पोकर हाथ को नाम दें

पांच कार्ड दिए गए, पोकर हैंड का नाम आउटपुट, जो निम्न में से एक होगा:

High card
One pair
Two pair
Three of a kind
Straight
Flush
Full house
Four of a kind
Straight flush
Royal Flush

यदि संदेह है, तो http://en.wikipedia.org/wiki/List_of_poker_hands पर नियमों का संदर्भ लें ।

इनपुट

स्टड या कमांडलाइन तर्कों से 5 कार्ड । एक कार्ड फॉर्म पर दो अक्षर का स्ट्रिंग होता है RS, जहां R रैंक होता है और S सूट होता है। रैंकों हैं 2- 9(संख्या कार्ड), T(दस), J(जैक), Q(रानी), K(राजा), A(ऐस)। सूट कर रहे हैं S, D,H , Cहुकुम, हीरे, दिल और क्लबों के लिए क्रमशः।

कार्ड का उदाहरण

5H - five of hearts
TS - ten of spades
AD - ace of diamonds

इनपुट का उदाहरण => वांछित आउटपुट

3H 5D JS 3C 7C => One pair
JH 4C 2C JD 2H => Two pair
7H 3S 7S 7D 7C => Four of a kind
8C 3H 8S 8H 3S => Full house

नियम

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

संपादित करें

अब तक बहुत अच्छा लग रहा है! मैं वास्तव में सभी उत्तरों को सत्यापित नहीं कर सकता, क्योंकि मैं इन भाषाओं को अच्छी तरह से नहीं जानता और इन सभी के लिए कंपाइलर / दुभाषिए नहीं हैं, लेकिन मुझे संदेह है कि हर किसी ने इस बारे में नहीं सोचा है इक्के उच्चतम और दोनों हो सकते हैं स्ट्रेट (फ्लश) के सबसे निचले कार्ड ।

code-golf  game 
— daniero
स्रोत
2
स्टैक ओवरफ्लो पर एक अस्पष्ट रूप से संबंधित पुराना है ।
— dmckee
क्या हमें कृपया नाम रखने (या न देने) की अनुमति है?
— श्री। छिपकली
मि। छिपकली, निश्चित।
— डैनिएरो

जवाबों:

3

गोल्फस्क्रिप्ट ( 209 208 207 206 200 199 197 196 वर्ण)

3/zip:^0={10,''*"TJQKA"+?}/]:?15,{?\{=}+,,}%2,-$6,14.),++@$/):|;[!!2*^1=.&,(!+5+]or{/}*'Full house
Two pair
One pair
ThreeKFourKHigh card
Flush
Straight''K'/' of a kind
'*n/~|1$"Royal"if" "+2$+](=

मैं पूंजीकरण को मुक्त करने की पेशकश की स्वतंत्रता का शोषण कर रहा हूं: मेरे फ्लश और रॉयल फ्लश दोनों को सरल फ्लश से शब्द का पुन: उपयोग करने के लिए फ्लश को कैपिटलाइज़ करें।

नोट: कुछ पहले के संस्करण छोटी गाड़ी थे: उन्होंने केवल पूर्ण घर का समर्थन किया था जब जोड़ी शाही से कम मूल्य की थी। - 0ए के साथ अलग होने वाले स्थान को बदलकर उन्हें ठीक किया जा सकता है $।

डेमो

— पीटर टेलर
स्रोत
अब यह एक गोल्फ का कार्यक्रम है! मैं इसे छोटा करने के तरीकों की तलाश कर रहा हूं, लेकिन कुछ भी नहीं कर सकता। .&एक स्ट्रिंग में अलग-अलग वर्णों को खोजने के लिए उपयोग करना एक बहुत ही उपयोगी चाल है।
— क्रिस्टियन लुपस्कू
@ w0lf, यह काफी मानक चाल है। हॉवर्ड अपने समाधान में भी इसका इस्तेमाल करते हैं।
— पीटर टेलर
8

मेरे खुद के एक जवाब के साथ आया :)

अजगर - 312 301 298

R,K,F,S,g=' 23456789TJQKA2345A',' of a Kind','Flush','Straight ',sorted
s,r=''.join(g(raw_input(),key=R.find)).split()
n,m=g(map(r.count,set(r)))[-2:]
print[[F,[0,'High Card','TOwnoe'[n&1::2]+' Pair',['Full House','Three'+K][n&1],'Four'+K][m]],[[S,'Royal '][r[0]=='T']+F,S]][r in R][len(set(s))>1]

एक 2x2 सूची बनाता है जहां दो आयामों के सूचक फ्लश और सीधे के लिए बूलियन चेक होते हैं। दोनों के मामले में, हम जांचते हैं कि यह एक शाही फ्लश है या सिर्फ एक सीधा फ्लश। फ्लश न करने और सीधे नहीं होने के लिए, हम दूसरे हाथों की जांच करते हैं: mऔर nसमान-रैंक कार्ड की उच्चतम और दूसरी सबसे अधिक मात्रा रखती है; हाथों के नामों को सूची के अनुसार सूचियों के साथ संग्रहित किया जाता है m। इस सूची के मूल्यों के भीतर उप-चेक nदो जोड़ी से एक जोड़ी को अलग करने के लिए किया जाता है, और घर से एक तरह का तीन।

संपादित करें: कुल 20 वर्णों के लिए धन्यवाद नोलेन रॉयलिटी!

— daniero
स्रोत
1
... और मेरी पिटाई।
— श्री। छिपकली
नए समाधान से प्यार करें, 312 अक्षर बहुत छोटे हैं। एक बनाम दो जोड़े से निपटने का बहुत ही चतुर तरीका: D
— Nolen Royalty
धन्यवाद :) यदि आप चाहते हैं तो आप इसका स्वागत करने के लिए तैयार हैं। लेकिन आप शायद मेरा और n के समान किसी भी वैरिएबल का उपयोग नहीं कर रहे हैं। यह जाँचना और आपका कोड फिर से देखना, मुझे बस एहसास हुआ कि मैं मूल पर कुछ और निकाल सकता हूँ ^ ^
— daniero
1
क्या आप स्विच m,n=g([c.count(x)for x in set(r)])करने से एक और 8 वर्ण नहीं खो सकते हैं m,n=g(map(c.count,set(r)))?
— नोलेन रॉयल्टी
वाह, आप सही समझ रहे हैं मैं: डी पता नहीं क्यों मेरे दिमाग में फिसल गया। अच्छी पकड़, धन्यवाद!
— डेनियरो
5

रूबी 1.9 (427 359 348 338 296 292)

संपादित करें : कम इक्के के साथ काम करने के लिए निश्चित।

o,p=%w(flush straight)
f=/1{5}|1{4}0+1$/
s=[0]*13
puts Hash[*$*.map{|c|s['23456789TJQKA'.index c[0]]+=1;c[1]}.uniq[1]?[f,p,?4,'four'+a=' of a kind',/3.*2|2.*3/,'full house',?3,'three'+a,/2.*2/,'two pair',?2,'one pair',0,'high card']:[/1{5}$/,'royal '+o,f,p+' '+o,0,o]].find{|r,y|s.join[r]}[1]

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

कार्ड को अलग-अलग कमांड-लाइन आर्ग के रूप में लेता है, जैसे:

>ruby poker-hand-golf.rb 3H 5D JS 3C 7C
one pair
— पॉल प्रेस्टिज
स्रोत
4

C, 454 वर्ण

#define L for(a=1;a<6;a++)for(b=0;b<13;b++)
#define U u[b+6]
#define R(x,y) if(x)puts(#y);else
b,f,r,h=0,s=0,u[20]={0};main(int a,char**v){L U+=v[a][0]=="23456789TJQKA"[b];f=v[1][1];L{if(v[a][1]!=f)f=0;u[a]+=a==U;if(b>7)h+=U;if(a*13+b<64||!U)r=0;else if(++r==5)s=1;}R(f&&h==25,Royal flush)R(f&&s,Straight flush)R(u[4],Four of a kind)R(u[3]&&u[2],Full house)R(f,Flush)R(s,Straight)R(u[3],Three of a kind)R(u[2]==2,Two pair)R(u[2],One pair)R(h,High card);}

तर्कों के रूप में कार्ड के साथ कमांड लाइन से चलाएं, जैसे / a.out 8C 3H 8S 8H 3S

टिप्पणियों के साथ विस्तारित संस्करण:

#define L for(a=1;a<6;a++)for(b=0;b<13;b++)
#define R(x,y) if(x)puts(#y);else
#define U u[b+6]
b,f,r,h=0,s=0,u[20]={0};
main(int a,char**v){
    // card usage - u[6..]
    L U+=v[a][0]=="23456789TJQKA"[b];
    // NOTE: lets expand the inner body of the loop in the answer so this looks more sane:
    // flush
    f=v[1][1];L if(v[a][1]!=f)f=0;
    // count of usages - u[0..5] 
    L u[a]+=a==U;
    // high cards x5
    L if(b>7)h+=U;
    // straights
    L if(a*13+b<64||!U)r=0;else if(++r==5)s=1;        
    // display
    R(f&&h==25,Royal flush)
    R(f&&s,Straight flush)
    R(u[4],Four of a kind)
    R(u[3]&&u[2],Full house)
    R(f,Flush)
    R(s,Straight)
    R(u[3],Three of a kind)
    R(u[2]==2,Two pair)
    R(u[2],One pair)
    R(h,High card);    
}

संपादन:

  1. लूप्स के संयोजन और पुन: उपयोग करके 12 चार्ट सहेजे गए।
  2. तार निरंतर स्थिर द्वारा 9 चार्ट सहेजा गया।
  3. मैक्रो, नॅस्टी में स्ट्रिंजिंग का उपयोग करके 19 चार्ट को सहेजा गया।
— बच्चे-खरगोश
स्रोत
3

गणितज्ञ , ३६५

यहां डेविड कैरर के जवाब पर मेरी राय है।

कुछ पठनीयता के लिए सफेद स्थान के साथ दिखाया गया है।

If[
  a = Characters;
  x = Thread;
  r = Range;
  d = Sort[a@StringSplit@# /. x[a@"23456789TJQKA" -> 2~r~14]];
  {t, u} = Sort[Last /@ Tally@#] & /@ x@d;
  c = First /@ d;
  f = u == {5};
  S = "Straight";
  c == r[b = d[[1, 1]], b + 4],
  If[f,
   If[c == 10~r~14, "Royal Flush", S <> " flush"], S],
  If[f, "Flush",
   Switch[t,
    {_, 4},    "Four of a kind",
    {2, 3},    "Full house",
    {__, 3},   "Three of a kind",
    {_, 2, 2}, "Two pair",
    {__, 2},   "One pair",
    _,         "High card"]
  ]
] &

एक पंक्ति संस्करण:

If[a=Characters;x=Thread;r=Range;d=Sort[a@StringSplit@#/.x[a@"23456789TJQKA"->2~r~14]];{t,u}=Sort[Last/@Tally@#]&/@x@d;c=First/@d;f=u=={5};S="Straight";c==r[b=d[[1,1]],b+4],If[f,If[c==10~r~14,"Royal Flush",S<>" flush"],S],If[f,"Flush",Switch[t,{_,4},"Four of a kind",{2,3},"Full house",{__,3},"Three of a kind",{_,2,2},"Two pair",{__,2},"One pair",_,"High card"]]]&
— Mr.Wizard
स्रोत
अच्छा लगा। आपको पैटर्न मिलान में सहेजने के लिए स्थान भी मिला। उदाहरण _के लिए{_,_,_,_}
— डेविड जूल
अच्छा समाधान, आप दोनों। चरित्र गणना के लिए, मुझे लगता है कि "जोड़ी" का नाम "वन जोड़ी" होना चाहिए, भले ही यह थोड़ा बुरा लगे, क्योंकि मैंने जो पोस्ट किया है और दूसरों ने इसे लागू किया है।
— डेनियरो
@ डानिएरो धन्यवाद। नाम ठीक कर लूंगा।
— मि। छिपकली
3

के, 294 295

d:{F:"Flush";S:"Straight ";P:" Pair";K:" of a kind";$[(f:1=#?,/-1#'c)&("AJKQT")~a@<a:,/j:1#'c:" "\:x;"Royal ",F;f&s:(4#1)~1_-':a@<a:,/(("A23456789TJQKA")!1+!14)@j;S,F;4=p:|/#:'=j;"Four",K;(2;3)~u:a@<a:,/#:'=j;"Full House";f;F;s;S;3=p;"Three",K;(1;2;2)~u;"Two",P;(1;1;1;2)~u;"One",P;"High Card"]}

।

k)d'("TS JS QS KS AS";"3S 4S 5S 7S 6S";"JC JH KS JD JS";"JC JH 2S JD 2C";"2C 9C TC QC 6C";"8C 5D 9H 6C 7D";"8C 8D 9H 8S 7D";"8C 8D 9H 2S 9D";"8C 8D 4H 2S 9D";"3C 8D 4H 2S 9D")
"Royal Flush"
"Straight Flush"
"Four of a kind"
"Full House"
"Flush"
"Straight "
"Three of a kind"
"Two Pair"
"One Pair"
"High Card"

संपादित करें: Ace-low straights के लिए 1 char जोड़ा गया

— tmartin
स्रोत
3

पायथन 334 , 326 322 वर्ण

p,f,l,t,o=" pair"," of a kind"," Flush","Straight","A23456789TJQK"
v,u=zip(*raw_input().split())
s=''.join(sorted(v,key=o.find))
print{5:"High card",7:"One"+p,9:"Two"+p,11:"Three"+f,13:"Full house",17:"Four"+f,23:t,24:l[1:],25:t,42:t+l,44:"Royal"+l}[(sum(map(v.count,v)),24)[len(set(u))<2]+((0,20)[s=="ATJQK"],18)[s in o]]

मुझे पता है कि पिछले एक लाइनर बहुत अपठनीय हो रहा है, मैं अपने समाधान से खुश होने पर एक गैर-गोल्फ संस्करण तैयार करूंगा।

— नोलेन रॉयल्टी
स्रोत
2

गोल्फस्क्रिप्ट, 258 250 वर्ण

3/zip~;.&,(!\{"23456789TJQKA"?}%$.(\{.@- 8%}%\;"\1"-!\.1/.&{1$\-,}%1.$?)"Four"" of a kind":k+{.,2="Full house"{.2\?)"Three"k+{.3-,({.3\?)"One pair"{;"Straight":?;2$2$&{(8="Royal"?if" flush"+}{;?{"Flush""High card"if}if}if}if}"Two pair"if}if}if}if])\;

कार्यक्रम एसटीडीआईएन पर इनपुट की अपेक्षा करता है जैसा कि ऊपर दिया गया है और एसटीडीयूएसटी को आउटपुट करता है। आप कोड का परीक्षण स्वयं कर सकते हैं ।

> 8C 3H 8S 8H 3S
Full house

> 8C 7H 6S TH 9S
Straight

> AH 3H 4S 2H 6S
High card

संपादित करें: w0lf के सुझाव शामिल।

— हावर्ड
स्रोत
अच्छा समाधान! आप " of a kind"एक चर में डालकर 3 वर्णों को बचा सकते हैं , क्योंकि यह दो बार उपयोग किया जाता है।
— क्रिस्टियन लुपस्कू
यह भी साथ काम करता है"Straight"
— क्रिस्टियन Lupascu
@ w0lf धन्यवाद। मैंने आपके सुझाव कोड में जोड़ दिए।
— हॉवर्ड
मुझे लगता है कि स्ट्रेट्स का पता लगाने के साथ एक सूक्ष्म बग है: AH KH 2C 3H 4Hएक सीधा माना जाता है, लेकिन उच्च कार्ड होना चाहिए।
— क्रिस्टियन लुपस्कू
@ w0lf हम्म, मुझे उस एक के बारे में सोचना है ...
— हॉवर्ड
2

गणितज्ञ - ५०० 494 465 वर्ण

यह समाधान एड पेग, जूनियर द्वारा एक पोकर प्रदर्शन पर आधारित है । इस संस्करण में, कार्डों को आंतरिक रूप से संख्याओं के रूप में माना जाता है।Range[2,14]

v[x_] := Block[{d, t, c, f, s},
 d = Sort@ToExpression[Characters[ImportString[x, "Table"][[1]]] /. {"T" -> 10, "J" -> 11, "Q" -> 12, "K" -> 13, "A" -> 14}];t = Sort /@ Map[Length, Split /@ Sort /@ Transpose@d, {2}];c = d[[All, 1]];f = (t[[2]] == {5});s = c == Range[b = d[[1, 1]], b + 4];
If[s,
 If[f, If[c == 10~Range~14, "royal flush", "straight flush"],"straight"],
 If[ f, "flush",
Switch[t[[1]],
 {1, 4}, "four of a kind",
 {2, 3}, "full house",
 {1, 1, 3}, "three of a kind",
 {1, 2, 2}, "two pair",
 {1, 1, 1, 2}, "one pair",
 {1, 1, 1, 1, 1}, "high card"]]]]

नमूना इनपुट, आउटपुट:

डेटा

टिप्पणियाँ:

एफ: फ्लश

सी: कार्ड (बिना सूट)

s: सीधे

t: {कार्ड, सुइट}

घ:

— DavidC
स्रोत
अच्छा लगा, लेकिन आप दो जोड़ी कैसे बना सकते हैं JH 4C 2C JD TH?
— डेनियारो
तुम सही हो। एक त्रुटि है जो तब उत्पन्न हुई जब मैंने कुछ घटकों को एक शुद्ध कार्य में शामिल किया। मैं इसे ट्रैक कर लूंगा।
— डेविड
@Daniero आपके द्वारा उठाए गए मुद्दे को संबोधित किया गया है।
— डेविड
डेविड, इसको कंप्रेस करने के लिए बहुत जगह है। क्या मैं?
— मि। छिपकली
@ Mr.Wizard मेरे मेहमान बनो। मैं देखूंगा और सीखूंगा।
— डेविड
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.