पोकर हाथ को नाम दें - 7 कार्ड संस्करण

Question

चुनौती:

इस प्रश्न में: उस पोकर हाथ को नाम दें जिसे आपको पाँच कार्ड का पोकर हाथ लेना था और उसकी पहचान करनी थी। यह प्रश्न समान है, दो ट्विस्ट के साथ:

सबसे पहले, आउटपुट सभी निचले मामलों में होगा। यह और अधिक गोल्फ के लिए अनुमति देता है, क्योंकि आप के पूंजीकरण के बारे में चिंता करने की जरूरत नहीं है flushऔरstraight

high card
one pair
two pair
three of a kind
straight
flush
full house
four of a kind
straight flush
royal flush

दूसरे, टेक्सास होल्डम और 7 कार्ड स्टड की लोकप्रियता के साथ, हम यहां कोड गोल्फ में सात कार्ड पोकर हैंड स्कोर कर सकते हैं क्या मैं सही हूं? सात कार्ड हाथ में लेते समय, अपने हाथ के लिए पांच सर्वश्रेष्ठ कार्ड का उपयोग करें और उन दो को अनदेखा करें जिनकी आपको आवश्यकता नहीं है।

संदर्भ:

पोकर हाथों की सूची: http://en.wikipedia.org/wiki/List_of_poker_hands

इनपुट (पिछले धागे से सीधे उठाया गया)

स्टड या कमांडलाइन तर्कों से 7 कार्ड । एक कार्ड फॉर्म पर दो अक्षर का स्ट्रिंग होता है 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 AH QS => one pair
JH 4C 2C 9S 4H JD 2H => two pair
7H 3S 7S 7D AC QH 7C => four of a kind
8C 3H 8S 8H 3S 2C 5D => full house
AS KC KD KH QH TS JC => straight

दूसरे उदाहरण में सूचना वास्तव में तीन जोड़े हैं, लेकिन आप केवल पांच कार्ड का उपयोग कर सकते हैं, इसलिए two pair। पांचवें उदाहरण में, दोनों एक three of a kindऔर एक straightसंभव हैं, लेकिन एक straightबेहतर है, इसलिए आउटपुट straight।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

शुद्धिपत्र

1. आप बाहरी संसाधनों का उपयोग नहीं कर सकते हैं।
2. ऐस उच्च और निम्न दोनों है।

Comments

अच्छा; मुझे चुपके से उम्मीद थी कि कोई गेंद उठाएगा। बस यह नोट करना चाहता था कि मेरे पास मूल प्रश्न में कैपिटलाइज़ेशन पर कोई प्रतिबंध नहीं था (एक टिप्पणी में स्पष्ट किया गया था), इसलिए आप "स्ट्रेट फ्लश" आउटपुट कर सकते थे (और सबसे अधिक / सभी)। IMHO पूंजीकृत बेहतर दिखता है।

— डानिएरो

आप कहते हैं कि इनपुट (पिछले धागे से सीधे उठा हुआ) 5 कार्ड। मुझे लगता है कि आप को बदलने का मतलब है 7.

— स्तर नदी सेंट

@steveverrill आप स्टैक एक्सचेंज पर पोस्ट को स्वयं संपादित कर सकते हैं। हालांकि मैंने इसे आपके लिए यहां किया था

— ड्यूर्रोन 597

क्या बाहरी संसाधनों की अनुमति है? लुकअप टेबल हैं जो आपको हाथ में प्रत्येक कार्ड को देखने और हाथ की ताकत प्राप्त करने की अनुमति देगा।

— केंडल फ्रे

क्या इक्का-दुक्का तिनके भी ऊँचे हो सकते हैं?

— निक टी

Answer 1

रूबी 353

यह मूल प्रश्न से क्रोन के उत्तर पर आधारित था ।

यह कमांड लाइन के तर्क के रूप में इनपुट लेता है। मूल रूप से हम आकार 5 के सभी संयोजनों पर ध्यान केंद्रित करते हैं कि यह किस प्रकार का हाथ है। प्रत्येक हाथ प्रकार को संशोधित किया गया था ताकि एक संख्या के साथ शुरू हो। ("शाही फ्लश" -> "0 ट्रॉयल 4flush", "हाई कार्ड" -> "9high कार्ड")। यह हमें उन स्ट्रिंग्स को सॉर्ट करने की अनुमति देता है जो वापस आ गए थे। छांटने के बाद पहला तार सबसे अच्छा संभव हाथ है। इसलिए हम स्ट्रिंग से सभी नंबरों को हटाने के बाद प्रिंट करते हैं।

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

Comments

अच्छा लगा। अंत में gsub सिर्फ एक उप अधिकार हो सकता है?

— बाज़रघ

@bazzargh नहीं इसे सभी नंबरों को हटाने की आवश्यकता है। कोड 1fl के साथ 4flush को समेटता है या "0royal 4 flush" या "1st right 4flush" पाने के लिए। यदि हम केवल उप का उपयोग करते हैं तो 4 को हटाया नहीं जाएगा।

— FDinoff

के लिए गलत परिणाम देता है AS QS JS TS 9S 5H 5D। यही कारण है कि आप एक चरित्र की लागत!

@ WumpusQ.Wumbley हम्म यह मूल कोड में एक बग लगता है। मैं कोशिश करूँगा और पता लगाऊंगा कि समस्या बाद में क्या है।

— FDinoff

Answer 2

हास्केल 618 603 598 525 512 504 480 464

इनपुट की एक पंक्ति के रूप में लिए गए कार्ड। मुझे लगता है कि मैंने इसे मौत के घाट उतार दिया है, लेकिन आसानी से एक ही चाल का उपयोग करके माणिक आदि द्वारा पीटा जाएगा: यदि आप सभी क्रमपरिवर्तन उत्पन्न करते हैं, तो आपको आगे के प्रकार मिलते हैं जो आप पट्टियों की तलाश करना चाहते हैं, साथ ही रिवर्स प्रकार जिन्हें आप परीक्षण के लिए चाहते हैं N एक तरह का।

import Data.List
m=map
z=take 5
q=m(\x->head[n|(f,n)<-zip"A23456789TJQK"[1..],f==x!!0])
l=m length
v=" of a kind"
w="flush"
y="straight"
c f s p r|f&&r="9royal "++w|f&&s='8':y++" "++w|f='5':w|s||r='4':y|True=case p of 4:_->"7four"++v;3:2:_->"6full house";3:_->"3three"++v;2:2:_->"2two pair";2:_->"1one pair";_->"0high card"
d x=c([5]==l(group$m(!!1)x))(q x==z[head(q x)..])(l$group$q x)$q x==1:[10..13]
k h=tail$maximum$m(d.z)$permutations$words h
main=interact k

@ FDinoff की प्रविष्टि को देखने के बाद इनलाइन "जोड़ी" का उपयोग किया और संख्या उपसर्गों का उपयोग किया, और भी अधिक चार दाढ़ी बनाने के लिए मानचित्र कार्यों की रचना की।

Comments

यदि आप यू से छुटकारा पा लेते हैं तो आप अपने आप को एक दो अक्षर बचा सकते हैं। "one pair","two pair"तब छोटा होता हैu=" pair" ... "one"++u,"two++u

— FDinoff

हाँ, मैं सिर्फ आपके कोड को पढ़ने के बाद यह परिवर्तन कर रहा था। इसके अलावा संख्या उपसर्ग तकनीक मुझे एक और 5 बचाता है

— bazzargh

Answer 3

सी ++, 622 553 चार्ट

चार अनावश्यक नएपन स्पष्टता के लिए नीचे जोड़े गए।

#include"stdafx.h"
#include"string"
std::string c=" flush",d=" of a kind",e="straight",z[10]={"high card","one pair","two pair","three"+d,e,c,"full house","four"+d,e+c,"royal"+c},
x="CDHSA23456789TJQK";char h[99];int main(){__int64 f,p,t,g,u,v,w,l=1,a=78517370881,b=a+19173960,i,j,q=0;gets_s(h,99);for(i=28;i-->7;){f=p=0;
for(j=7;j--;)if(j!=i%7&j!=(i+i/7)%7){f+=l<<x.find(h[j*3+1])*6;p+=l<<x.find(h[j*3])*3-12;}
v=p&b*2;u=v&v-1;w=p&p/2;g=p*64&p*8&p&p/8&p/64;f&=f*4;t=f&&p==a?9:f&&g?8:p&b*4?7:u&&w?6:f?5:g||p==a?4:w?3:u?2:v?1:0;
q=t>q?t:q;}puts(z[q].c_str());}

गोल्फ संस्करण में चीजें बदल गईं:

Rev 1: __int64एकल घोषणा के लिए सभी संख्यात्मक चर को बदल दिया ।

Rev 1: forछोरों की गोल्फ वृद्धि और स्थिति

Rev 0: दशमलव में परिवर्तित अष्टकोणीय स्थिरांक।

Rev 0: ifसशर्त ऑपरेटर के साथ असाइनमेंट में परिवर्तित कथन। Rev 1: के लिए एक एकल अभिव्यक्ति में आगे बढ़ाया t। यह vमध्यवर्ती मूल्यों में से एक के लिए नए चर की आवश्यकता है

Rev 0: हटाए गए वर्बोज़ आउटपुट। केवल सबसे अच्छा समग्र हाथ आउटपुट।

Rev 0: आउटपुट टेक्स्ट को संपीड़ित करने में कठिनाई हुई (C में मुश्किल है क्योंकि आप + ऑपरेटर का उपयोग करके तारों को नहीं मिला सकते हैं।) "फ्लश" लिखना केवल एक बार मुझे 12 वर्णों को बचाता है, लेकिन मुझे 15 का खर्च करना पड़ता है, जिससे मुझे कुल मिलाकर 3 वर्ण बिगड़ जाते हैं। इसलिए मैंने इसके बजाय सिर्फ 3 बार लिखा। Revin 1: FDinoff द्वारा सुझाए गए के std::stringबजाय उपयोग किया जाता है char[], जिससे यह संभव हो जाता है +।

अनगोल्डेड संस्करण, 714 गैर-विहीन नॉनवॉइटस्पेस वर्ण।

सभी 21 संभावित हाथों से लूप्स जो कि 7 कार्डों से बनाए जा सकते हैं और हर बार 2 कार्डों को अस्वीकार कर सकते हैं। पांच चुने हुए कार्डों के सूट और रैंक को चर में फिट किया गया है और प्रत्येक सूट / रैंक के लिए एक अलग ऑक्टल अंक के साथ पी। हाथ के प्रकार को निर्धारित करने के लिए विभिन्न बिट संचालन किए जाते हैं, जिसे तब टी में संग्रहित किया जाता है (सभी 21 संभावनाएं ungolfed संस्करण में आउटपुट हैं।) अंत में सबसे अच्छा संभव हाथ आउटपुट है।

#include "stdafx.h"
#include "string.h"

char x[] = "CDHSA23456789TJQK", h[99], z[10][99] = 
{ "high card", "one pair", "two pair","three of a kind", "straight","flush","full house","four of a kind","straight","royal" };

int main(void)
{
        int i,j,q=0;                  //i,j:loop counters. q:best possible hand of 7 card   
        scanf_s("%s/n", &h, 99); getchar();
        for (i = 7; i < 28; i++){

          //f,p: count number of cards of each suit (2 octal digits) and rank (1 octal digit.)
          //t: best hand for current 5 cards. g:straight flag. u,w: flags for pairs and 3's.   
          //l: constant 1 (64bit leftshift doesn't work on a literal.) 
          //octal bitmasks: a=ace high straight, b=general purpose

            __int64 f=0,p=0,t=0,g,u,w,l=1,a=01111000000001,b=a+0111111110;

           for (j = 0; j < 7; j++){
               if (j != i %7 & j != (i+i/7) %7){

                   f += l << (strchr(x,h[j*3+1])-x)*6;
                   p += l << (strchr(x,h[j*3])-x-4)*3;

                   printf_s("%c%c ",h[j*3], h[j*3+1]);
               }
           }

           w=p&b*2;                          //if 2nd bit set we have a pair
           if (w) t=1;
           u= w & w-1;                       //if there is only one pair w&w-1 evaluates to 0; +ve for 2 pair.
           if (u) t=2;
           w = p & p/2;                      // if 2nd and 1st bit set we have 3 of kind. 
           if (w) t=3;
           g = p*64 & p*8 & p & p/8 & p/64;  // detects all straights except ace high. pattern for ace high in a.
           if (g||p==a) t=4;
           f&=f*4;                           //for a flush we want 5 cards of the same suit, binary 101
           if (f) t=5;
           if (u&&w) t=6;                    //full house meets conditions of 2 pair and 3 of kind
           if (p & b*4) t=7;                 //four of a kind
           if (f && g) t=8;                  //straight flush
           if (f && p==a) t=9;               //royal flush
           printf_s("%s %s \n",z[t],t>7?z[5]:"");
           q=t>q?t:q;
        }   
        printf_s("%s %s",z[q],q>7?z[5]:"");
        getchar();
}

अघोषित उत्पादन

Comments

चूँकि आप कहते हैं कि आप c ++ का उपयोग कर रहे हैं, इसलिए आप इसे उपयोग कर सकते हैं <string>जो स्ट्रिंग के संयोजन के लिए समर्थन + करता है। जिसका मतलब है कि आप शायद उपयोग कर सकते हैं <iostream>और उपयोग कर सकते हैं, coutहालांकि मुझे वास्तव में नहीं पता है कि उनमें से कोई भी छोटे चरित्र की गिनती में ले जाएगा।

— FDinoff

@Finoff मैं क्या बचा सकता है: " pair flush flush straight of a kind"= 35 चार्ट । एक बार जब आप #includeबचत में जोड़ते हैं तो न्यूनतम होते हैं, फिर आपको ",=+स्थिरांक की अतिरिक्त और घोषणाओं पर विचार करना होगा । इसके अलावा, मैं C ++ में नया हूं और IDE और कंपाइलर सेटिंग्स के साथ संघर्ष कर रहा हूं (यह मुझे पुराने "असुरक्षित" संस्करणों के बजाय उपयोग करने के लिए मजबूर करता है scanf_sऔर printf_sइसे ठीक करने के बारे में मदद से सर्कल में चक्कर आता है।) coutथोड़ी मदद कर सकता है, यह मेरे पर है। सूची करें, लेकिन शायद दूसरे कार्यक्रम के लिए। coutमेरे लिए जो चीज मुझे मारती है , वह यह है कि using namespace stdक्या मुझे पता नहीं है कि यह सब लिखने से बचने का कोई तरीका है।

— लेवल रिवर सेंट

जब से आप c ++ का उपयोग कर रहे हैं, तब आपको लगभग कभी भी printf और scanf की आवश्यकता नहीं होनी चाहिए। वहाँ अन्य (सुरक्षित) एक ही काम करना था। आप std::coutusing namespace std

— FDinoff

टिप के लिए @Finoff thx। अपने नवीनतम संपादन में मैंने 18 बाइट्स को अलग-अलग स्ट्रिंग हैंडलिंग से बचा लिया: gets_s& puts, साथ std::stringही समतल करने के लिए, जिसका अर्थ है कि मुझे char*आउटपुट में बदलना होगा । मैंने जो गोल्फ पोस्ट किया है, वह सिर्फ stringया सिर्फ iostream.विचित्र रूप से काम करता है, मुझे दोनों <<>>ऑपरेटरों को cin/cout& std::strings के साथ काम करना चाहिए । कुल मिलाकर, दोनों #includeएस का उपयोग करने से 5 बाइट्स बदतर हो जाते हैं, भले ही मैं hएक के रूप में घोषणा कर सकता हूं std::stringऔर एक अलग charघोषणा से बच सकता हूं । मुख्य रूप से, मुझे namespace stdमदद में (या ऑपरेटर के बारे में स्पष्टीकरण) क्या है की एक सूची मिल सकती है

— लेवल रिवर सेंट

@Finoff मैं सहमत हूँ, मैं सामान्य रूप से उपयोग नहीं करूँगा scanfऔर gets, गोल्फिंग को छोड़कर, जहाँ प्रोग्राम वैसे भी बहुत असुरक्षित हैं। मैं 5 बाइट्स को छोटा कर सकता हूं -s,99अगर मैं getsइसके बजाय उपयोग कर सकता हूं gets_s, लेकिन मुझे मुझे जाने के लिए संकलक नहीं मिल सकता है। मुझे आश्चर्य है कि सामान्य रूप से असुरक्षित C / C ++ कैसे है! कुछ हफ़्ते पहले यह मुझे हैरान कर _int64 x=1<<yदेता था कि 31 से अधिक y के लिए गलत उत्तर देता है। लेकिन अब मैं बस हल्के से नाराज हूं। कोई त्रुटि संदेश के साथ सीमा से बाहर जाने वाले सरणी सबस्क्राइब के साथ चीजों को देखने के बाद, मुझे इसकी आदत हो गई है। क्या बेहतर जाँच चालू करने का कोई तरीका है?

— लेवल रिवर सेंट

Answer 4

पर्ल (> = 5.14), 411 403 400 397 400

संपादित करें : एक उप को केवल 8 वर्णों की बचत करते हुए एक बार बुलाया गया।
संपादित करें 2 : एक को हटा दिया .""गया था कि एक प्रारंभिक प्रयास से अधिक छोड़ दिया गया था
संपादित करें 3 : एक अस्थायी चर के बजाय जो मूल को संरक्षित करता है $_, इसे अनावश्यक बनाने के लिए एक का उपयोग करें। शुद्ध लाभ 3 वर्ण।
संपादित करें 4 : पूर्ण-पूर्ण पूर्ण घर (2x 3-ऑफ-ए-तरह) का पता लगाने में निश्चित विफलता। लागत 3 चार्ट।

काफी विजेता नहीं, लेकिन सीधे डिटेक्टर एक दिलचस्प अवधारणा है, मुझे लगता है।

sub
j{join"",sort@_}sub
o{j(map{{A=>10}->{$_},11+index(j(2..9).TJQKA,$_)}$h=~/(.(?=@_))/g)=~/.*(..)(??{j
map$1+$_.'.*',1..4})/?$1:()}$h=$_=<>;if(j(/(\S)\b/g)=~/(.)\1{4}/){$w=$_==19?royal:straight
for
o$f=$1}$_=j(/\b(\S)/g)=~s/(.)\1*/length$&/rge;$k=" of a kind";print$w?"$w flush":/4/?four.$k:/3.*2|[23].*3/?"full house":$f?flush:(o".")?straight:/3/?three.$k:/2.*2/?"two pair":/2/?"one pair":"high card"

विस्तारित संस्करण:

# We'll be doing a lot of sorting and joining
sub j {
  return join "", sort @_;
}

# r() expects $_ to contain a rank, and converts it to a numeric code. The
# code starts at 10 so the numbers will sort correctly as strings, and a list
# of 2 values is returned because A is both 10 and 23. All other ranks have
# undef as the first value and their proper 11..22 value as the second value.
sub r {
  return ({A=>10}->{$_}, 11+index(j(2..9).TJQKA,$_));
}

# Sequence-detector. Factored into a sub because it's run twice; once over
# the ranks in the flush suit to find a straight flush and once over all the
# ranks to find a straight. On successful match, returns the lowest rank of
# the straight (in the 10..23 representation).
# Required parameter: the suit to search, or "." for all suits.
sub o {
  j(map r,$h=~/(.(?=@_))/g)          # The list of ranks, in increasing order,
                                     # with ace included at both ends...
    =~                               # ...is matched against...
  /.*(..)(??{j map$1+$_.'.*',1..4})/ # ...a pattern requiring 5 consecutive
                                     # numbers.
  ?$1:()
  # A note about this regexp. The string we're matching is a bunch of numbers
  # in the range 10..23 crammed together like "121314151619" so you might
  # worry about a misaligned match starting on the second digit of one of the
  # original numbers. But since that would make every pair of digits in the
  # match end with a 1 or a 2, there's no way 5 of them will be consecutive.
  # There are no false matches.
  # Another note: if we have a royal flush and also have a 9 in the same
  # suit, we need to return the T rank, not the 9, which is why the regexp
  # starts with a .*
}

# Read a line into $_ for immediate matching with /.../ and also save it into
# $h because $_ will be clobbered later and we'll need the original string
# afterwards.
$h = $_ = <>;

if(j(/(\S)\b/g) =~ /(.)\1{4}/) { # flush detector: sorted list of all suits
                                 # contains 5 consecutive identical chars
  # $f=$1 comes first, so $f will be true later if there's a flush.
  # Then o() is called with the flush suit as arg to detect straight flush.
  # If there's no straight flush, o() returns the empty list and for loop
  # runs 0 times, so $w is not set. If there is a straight flush, the return
  # value of o() is compared to 19 to detect royal flush.
  $w = ($_==19 ? "royal" : "straight")
    for o($f=$1);
}

$_ =
  j(/\b(\S)/g)                 # Get the sorted+joined list of ranks...
    =~ s/(.)\1*/length $&/rge; # ... and turn it into a list of sizes of
                               # groups of the same rank. The /r flag
                               # requires perl 5.14 or newer.

print
  $w             ? "$w flush" :
  /4/            ? "four of a kind" :
  /3.*2|[23].*3/ ? "full house" :
  $f             ? "flush" :
  (o".")         ? "straight" :
  /3/            ? "three of a kind" :
  /2.*2/         ? "two pair" :
  /2/            ? "one pair" :
                   "high card"

Answer 5

जावास्क्रिप्ट 600

नोडजेएस के साथ उपयोग: node code.js "7H 3S 7S 7D AC QH 7C"

function a(o){s="";for(k in o)s+=o[k];return s}
b=process.argv[2]
c={S:0,H:0,D:0,C:0}
v={A:0,K:0,Q:0,J:0,T:0,"9":0,"8":0,"7":0,"6":0,"5":0,"4":0,"3":0,"2":0}
d=b.split(" ")
for(i=d.length;i--;){e=d[i];c[e[1]]++;v[e[0]]++}
c=a(c);v=a(v)
f=g=h=j=k=l=m=false
if((st=c.indexOf(5))!=-1)g=!g
if(v.match(/[1-9]{5}/))h=!h
if(st==0)f=!f
if(v.indexOf(4)!=-1)j=!j
if(v.indexOf(3)!=-1)k=!k
if(n=v.match(/2/g))if(n)if(n.length>=2)m=!m;else l=!l
p=" of a kind"
q="Flush"
r="Straight"
console.log(f&&g?"Royal "+q:h&&g?r+" "+q:j?"Four"+p:k&&(l||m)?"Full House":g?q:h?r:k?"Three"+p:m?"Two pairs":l?"Pair":"High card")