21

^{संबंधित: पोकर हाथ को नाम दें}

एक सीधा फ्लश एक पोकर हाथ है जिसमें अनुक्रमिक रैंक के पांच कार्ड हैं, सभी एक ही सूट के हैं। एक सीधे फ्लश के हिस्से के रूप में, एक इक्का एक राजा के ऊपर या दो से नीचे रैंक कर सकता है। ऐस या तो उच्च रैंक कर सकता है (जैसे A ♥ K ♥ Q ♥ J ♥ 10 ♥ एक ऐस-हाई स्ट्रेट फ्लश है) या निम्न (जैसे 5 ♦ 4 ♦ 3 ♦ 2 ♦ A five पांच-उच्च स्ट्रेट फ्लश है), लेकिन एक ही हाथ में उच्च और निम्न दोनों रैंक नहीं कर सकते हैं (जैसे क्यू ♣ K ♣ A ♣ 2 ♣ 3-एक ऐस-उच्च फ्लश है, न कि एक सीधा फ्लश)।

चुनौती

दिए गए Nकार्ड (किसी भी उचित प्रारूप में) एक सत्य मूल्य का उत्पादन करते हैं यदि एक सीधा फ्लश पोकर हाथ में निहित होता है।

इनपुट

Nकार्ड की संख्या। (किसी भी उचित प्रारूप में)

चार सूट हैं; दिल, हुकुम, हीरे और क्लब (H, S, D, C)।

प्रत्येक सूट में 2 से 10 की संख्या के लिए एक कार्ड होता है, साथ ही 4 'चित्र' कार्ड, ऐस, जैक, क्वीन और किंग (A, J, Q, K)

नोट: आप 10 को T के रूप में ले सकते हैं

उत्पादन

Truthy/Falsy मूल्य

परीक्षण का मामला

["AS", "2S", "3S", "4S", "5S"] => true

["3D", "9C", "4S", "KH", "AD", "AC"] => false

["5D", "6D", "7D", "8H", "9D", "10D", "JD"] => false

["JC", "7C", "5D", "8C", "AC", "10C", "9C", "5S"] =>true

[] => false

["AS", "2S", "3S"] => false

["JC", "QC", "KC", "AC", "2C"] => false

[ "2H", "3H", "4H", "5H", "6H", "7H"] => true

मानक कोड-गोल्फ नियम लागू होते हैं।

जीत के मापदंड: प्रत्येक लैंग में सबसे छोटा कोड

code-golf decision-problem

— लुइस फेलिप डी जीसस मुनोज
स्रोत

1

क्या हम यह मान सकते हैं कि हाथ में एक ही कार्ड नहीं होगा?

— जो किंग

@JoKing हां, आपके पास एक ही कार्ड दो बार या उससे अधिक नहीं होगा

— लुइस फेलिप डी जीसस मुनोज

4

हम के 10रूप में ले सकते हैं T?

— केविन क्रूज़सेन

@JoKing मुझे नहीं लगता कि IRL हो सकता है। ;-)

— एरिक आउटलेफ़र

4

@EriktheOutgolfer मेरे पास मिश्रित कार्ड के लगभग 5 पैक कम हैं, फिर मुझसे एक मीटर की दूरी पर है

— Jo King

15

पायथन 2 , 95 बाइट्स

lambda a:any(set('A234567891JQKA'[i/4:][:5])<={r['HCSD'[i%4]in r]for r in a}for i in range(40))

इसे ऑनलाइन आज़माएं!

40 संभावित सीधे फ्लश हैं, और यह बस उन सभी की जांच करता है। चास ब्राउन ने 2 बाइट्स बचाए; जो राजा ने 4 और बचाए।

— लिन
स्रोत

1

40 हैं, आपने Aदोनों छोर पर उपयोग किया है इसलिए मेरा मानना है कि इसे बदलने के 36लिए 40इसे ठीक करना चाहिए।

— जोनाथन एलन

ओह, मैं गिनती में अच्छा नहीं हूं। मैंने ठीक कर दिया!

— लिन

99 बाइट्स ।

— चास ब्राउन

सूट-वैल्यू ऑर्डर को स्वैप करें और अगर इंडेक्स को इंडेक्स करें?

— जो किंग

95 बाइट्स

— जो किंग

8

आर , 128 126 94 91 बाइट्स

function(x,r=rle(outer(y<-chartr("J-X","A2-9TJQKAS",LETTERS),y,paste0)%in%x))any(r$l>4&r$v)

इसे ऑनलाइन आज़माएं!

मूल तर्क @ J.Doe द्वारा काफी छोटा कर दिया गया।

ज्यादातर बकवास के साथ 26 मैट्रिक्स द्वारा 26 बनाता है, लेकिन सभी कार्ड (नीचे में दोहराए गए इक्के के साथ) 10 से 23 कॉलम 3,4,8 और 24 की पंक्तियों में समाहित हैं। मैट्रिक्स ऊपरी मामले के सभी संयोजनों को मिलाते हुए बनाया गया है X, A, 2-9, T, J, Q, K, A, S द्वारा प्रतिस्थापित X के माध्यम से अक्षर J के साथ वर्णमाला chartr। हमें C, D, H मुफ्त में मिलते हैं!

%in%एक वेक्टर में मैट्रिक्स सपाट स्तंभ-वार। फिर देखें कि किसी रन के TRUEमैच के लिए रन-लेंथ एन्कोडिंग 4 से अधिक है या नहीं ।

— एनजीएम
स्रोत

चालाक का उपयोग rleऔर outer! यह दो बाइट्स बचाता है

— JayCe

94 बाइट्स। दो परिवर्तन: एक सिमेट्रिक outerकॉल का उपयोग करना जो कई अमान्य कार्डों का उत्पादन करता है, और inबचने के लिए वेक्टर बल प्रयोग का उपयोग करता है apply। काम करने के लिए इन दोनों को जगह देनी होगी!

— जे।

2

बहुत अच्छा! उत्तर को बदल दिया और इसे सामुदायिक विकि बना दिया।

— 13:14 बजे एनजीएम

5

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

a=>[...'CDHS'].some(s=>a.map(c=>m|=c.match(s)&&2<<"234567891JQKA".search(c[0]),m=0)|(g=k=>k&&1+g(k&k/2))(m|m>>13)>4)

इसे ऑनलाइन आज़माएं!

कैसे?

$s$ $c$ $s$ $m$

— Arnauld
स्रोत

5

मुझे आपकी "क्युरिंग नोटेशन" परिचयात्मक रेखा से इतनी आदत हो गई है कि मुझे इसकी आवश्यकता होने पर याद आती है।

— एन जी एम

4

ब्रेकीलॉग , 31 बाइट्स

tᵍkᵐ²cᵐ{ps₅~s"A23456789TJQKA"}ᵉ

इसे ऑनलाइन आज़माएं!

 ᵍ                    Group input by
t                     each element's "tail" (i.e. suit)
kᵐ²                   Knife off the suit character from each element in each array
cᵐ                    Concatenate the elements of each suit array into a string
{               }ᵉ    There exists at least one string in that such that
 p                    it has a permutation
 s₅                   which has a substring of length 5
 ~s                   which is also a substring of
 "A23456789JQKA"

— sundar - मोनिका को बहाल करना
स्रोत

3

रेटिना 0.8.2 , 66 बाइट्स

J
11
Q
12
K
13
A
1$%'¶14
\d+(.)
$1$&$*
O`
^
¶
((?(1)\1.|¶.+)){5}\b

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

J
11
Q
12
K
13

चित्र कार्डों को उनके मूल्यों में परिवर्तित करें।

A
1$%'¶14

A 1 या 14 हो सकता है।

\d+(.)
$1$&$*
O`

मान को एक में परिवर्तित करें, और इसे प्रत्यय दें ताकि कार्ड ठीक से सॉर्ट करें।

^
¶
((?(1)\1.|¶.+)){5}\b

प्रत्येक बार 1 से बढ़ने वाले 5 कार्ड का मिलान करें, और सुनिश्चित करें कि अंतिम वृद्धि बिल्कुल 1 थी।

— नील
स्रोत

2

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

h=>h.map(([r,s])=>[..."HSDCA23456789TJQKA"].map(c=>i+=c==s?i*15:c==r?d[i]=1:1,i=0),d=[])|/(,1){5}/.test(d)

कार्ड के स्ट्रिंग प्रतिनिधित्व का एक सरणी स्वीकार करता है, के 10साथ बदल रहा है T। इसे ऑनलाइन आज़माएं!

व्याख्या

प्रत्येक कार्ड पर Iterates और अपने रैंक और सूट के अनूठे संयोजन से गणना किए गए सूचकांक का उपयोग करके बूलियन की एक सरणी में एक ध्वज सेट करता है। यह सरणी 5 निरंतर सत्य मानों के पैटर्न से मेल खाने की अनुमति देने के लिए कठोर है।

उदाहरण के लिए, एक सीधे फ्लश के साथ एक हाथ बूलियन सरणी के पूर्ण स्ट्रिंग प्रतिनिधित्व के विकल्प के रूप में निम्नलिखित का उत्पादन कर सकता है: ,,,,1,1,1,1,1,,,,

क्योंकि पहला रैंक मान (यानी ए) स्ट्रिंग की शुरुआत से ऑफसेट है, हमेशा 1सरणी में सभी पूर्ववर्ती खाली मान होंगे , यह सुनिश्चित करना स्ट्रिंग का प्रतिनिधित्व एक के साथ शुरू होगा,

h =>
    h.map(([r, s]) =>                         // destructure card value, e.g. "JH" => ["J", "H"]
        [..."HSDCA23456789TJQKA"].map(c =>    // mapping accounts for both positions of 'A'
            i +=                              // increment index value
            c == s                            // if found index of suit...
                ? i * 15                      // buffer so that cards from different suits cannot be confused
            : c == r                          // if found index of rank...
                ? d[i] = 1                    // set flag to denote card is in hand
            : 1,
            i = 0
        ),
        d = []
    ) |
    /(,1){5}/.test(d)                         // implicitly converts to string joined with a ,

— फालतूपन
स्रोत

2

अच्छा लगा। यह अधिक वोटों का हकदार है, लेकिन लोग शुरुआती पोस्टिंग के बाद कुछ दिनों में चुनौतियों में रुचि खो देते हैं।

— रिक हिचकॉक

2

जावा 10, 189 167 165 164 160 157 156 बाइट्स

s->{int i=10;for(;i-->0;)i=s.matches("AKQJT98765432A".substring(i,i+5).replaceAll(".","(?=.*$0\\\\1)").replaceFirst(".1","([HSDC])")+".*")?-2:i;return-1>i;}

इनपुट को सिंगल स्पेस-सीमांकित स्ट्रिंग (यानी "AS 2S 3S 4S 5S") के रूप में लेता है ।

-22 बाइट्स की बदौलत @ OlivierGrégoire ।
-1 बाइट @AlexRacer को धन्यवाद ।

इसे ऑनलाइन आज़माएं।

कोड का गोल्फ संस्करण जो मैंने प्रोजेक्ट यूलर # 54 के लिए उपयोग किया है , जो कि मैंने मुख्य रूप से रेगीक्स के साथ किया था (मस्ती के लिए और रेगेक्स के बारे में अधिक जानने के लिए)। Regexes के बिना यह शायद प्रदर्शन और आसान के लिए बेहतर होता (शायद यह जवाब गोल्फिंग के लिए भी लागू होता है; बाद में एक बार देख लेंगे)।

स्पष्टीकरण:

s->{                    // Method with String parameter and boolean return-type
  int i=10;for(;i-->0;) //  Loop `i` in the range (10,0]:
    i=s.matches(        //   If the input matches the following regex:
        "AKQJT98765432A".substring(i,i+5)
                        .replaceAll(".","(?=.*$0\\\\1)")
                        .replaceFirst(".1","([HSDC])")
                        //    Five adjacent cards
        +".*")?         //    With optionally zero or more other characters
         -2             //     Set `i` to -2, which also stops the loops at the same time
      :i;               //   Else: leave `i` unchanged to continue
  return-1>i;}          //  Return whether `i` is not -2 (so whether the loop has finished)

अतिरिक्त रेगेक्स स्पष्टीकरण:

"AKQJT98765432A".substring(i,i+5) के आधार पर पाँच आसन्न कार्ड लेता है i
.replaceAll(".","(?=.*$0\\\\1)")उन कार्डों में से प्रत्येक को बदल देता है "(?=.*c\\1)"(जहां cकार्ड-वर्ण है)
.replaceFirst(".1","([HSDC])")तो पहले स्थान ले लेगा \\1साथ ([HSDC])।

यानी वैल्यू-रेंज में कार्ड के लिए स्ट्रेट फ्लश की जांच करने के लिए कुल रेगेक्स [9,5]बन जाएगा:
^(?=.*9([HSDC]))(?=.*8\\1)(?=.*7\\1)(?=.*6\\1)(?=.*5\\1).*$
(नोट: String#matchesस्पष्ट रूप ^...$से पूरे स्ट्रिंग की जांच करने के लिए अनुगामी / अग्रणी जोड़ता है ।) यह रेगेक्स होगा:

^(?=.*9([HSDC]))(?=.*8\\1)(?=.*7\\1)(?=.*6\\1)(?=.*5\\1).*$
^                                                         $ Match the entire string
 (?=           )(?=      )(?=      )(?=      )(?=      )    Do positive lookaheads to check
                                                            each card
    .*             .*        .*        .*        .*         With optional leading characters
                                                            in front of every card
                                                        .*  And any trailing characters at
                                                            the end of the entire hand
      9              8         7         6         5        The five adjacent values
        [HSDC]                                              With a suit
       (      )       \\1       \\1       \\1       \\1     which is the same for all cards

— केविन क्रूज़सेन
स्रोत

1

172 बाइट्स । मैंने केवल रेगेक्स पीढ़ी को गढ़ा है: यह अभी भी आपका एल्गोरिथ्म है।

— ओलिवियर ग्राएगोइरे

1

167 बाइट्स । मैंने अनावश्यक ".*"+उपसर्ग को हटा दिया ।

— ओलिवर ग्राएगोइरे

1

@ OlivierGrégoire धन्यवाद! अच्छा गोल्फ है।

— केविन क्रूज़सेन

1

-1 बाइट यदि आप उपयोग करने के बजाय लूप से बाहर f

— निकलते हैं

1

@AlexRacer स्मार्ट, धन्यवाद! और बदलकर 2 अधिक बाइट्स गोल्फ करने में सक्षम breakकरने के लिए i=-2और करने के लिए वापसी return-1>i;अपने दृष्टिकोण का उपयोग कर (और 2 अधिक बदल रहा है (.)करने के लिए .और $1करने के लिए $0)। :)

— केविन क्रूज़सेन

1

क्लीन , 145 135 बाइट्स

import StdEnv,Data.List
?l=or[isInfixOf(map hd h)['A234567891JQKA']\\a<-l,b<-l,c<-l,d<-l,e<-l,h<-[[a,b,c,d,e]]|tl(nub(map last h))==[]]

इसे ऑनलाइन आज़माएं!

सरलीकृत:

? l                                             // function ? taking argument l
  = or [                                        // is at least one of these true
        isInfixOf (map hd h) ['A234567891JQKA'] // do the first characters of a hand appear in this string, in order
        \\ a <- l                               // loop level 1, assigns `a`
           , b <- l                             // loop level 2, assigns `b`
             , c <- l                           // loop level 3, assigns `c`
               , d <- l                         // loop level 4, assigns `d`
                 , e <- l                       // loop level 5, assigns `e`
                   , h <- [[a,b,c,d,e]]         // trick to assign `h`, because it's cheaper than let .. in ..
        | tl (nub (map last h)) == []           // only take the loop iterations where all the suits are the same
       ]

— Οurous
स्रोत

1

जाप , 37 बाइट्स

एक 2 डी सरणी के रूप में इनपुट लेता है।

"AJQKA"i1Aò2 q)øUñÌòÏÌ¦XÌÃËmÎ¬ú5 á5Ãc

कोशिश करो

व्याख्या

"AJQKA"                                   :String literal
       i1                                 :Insert at (0-based) index 1
         Aò2                              :  Range [2,10]
             q                            :  Join
              )                           :End insert
               ø                          :Does that string contain any element in the following array?
                U                         :Input
                 ñ                        :Sort
                  Ì                       : By last element (grouping suits together)
                   òÏ                     :Partition between X & Y where
                     Ì                    :  Last element of Y
                      ¦                   :  Does not equal
                       XÌ                 :  Last element of X
                         Ã                :End partition
                          Ë               :Map
                           m              :  Map
                            Î             :   First elements (card values)
                             ¬            :  Join
                              ú5          :  Right pad with spaces to length 5
                                 á5       :  Permutations of length 5
                                   Ã      :End map
                                    c     :Flatten

— झबरा
स्रोत

0

जेली , 18 बाइट्स

Ṣœc5Uµ13R;1wṪ€ȧEµƇ

इसे ऑनलाइन आज़माएं!

[..., ...] $[1,13]$ $A23456789TJQK$ $[1,4]$ $CDHS$

आउटपुट स्वरूप: खाली सूची झूठी के रूप में, सत्य के रूप में गैर-रिक्त सूची।

— आउटगोल्फर को एरिक करें
स्रोत

मुझे चश्मे में कुछ भी दिखाई नहीं दे रहा है जो बताता है कि पूर्णांक सूट और चित्र कार्ड के लिए प्रतिस्थापित किया जा सकता है - क्या मुझे कुछ याद आया?

— झबरा

@ शैगी मुझे लगता है कि "किसी भी उचित प्रारूप" में है, मुझे नहीं लगता कि हमारे पास कार्ड खेलने के बारे में कोई चूक है।

— आउटगॉल्फ जूल

0

PHP , 264 बाइट्स

यह इको है 1अगर यह एक सीधा फ्लश है और 0या nullनहीं तो।

यदि आप फ़ाइल को नाम देते हैं 1Xतो आप सहेज सकते हैं 11 bytesक्योंकि आपको बदलने की आवश्यकता नहीं है $argv[0]। फिलहाल इस बात पर यकीन नहीं है कि फाइलन इसे क्यों तोड़ सकता है।

किसी कारण से तार TIO द्वारा :;<=>तार 0123456789से पहले हल हो जाते हैं asort, भले ही :;<=>ASCII मान 58-62 हो और 0123456789ASCII मान 48-57 हो। इसलिए यदि आप TIO लिंक या नीचे से कोड लेते हैं और निम्न परीक्षण सूट के साथ PHPTester का उपयोग करते हैं ।

$argb[0] = [".code.tio", "AS", "2S", "3S", "4S", "5S"]; // => true
$argb[1] = [".code.tio", "3D", "9C", "4S", "KH", "AD", "AC"]; // => false
$argb[2] = [".code.tio", "5D", "6D", "7D", "8H", "9D", "TD", "JD"]; // => false
$argb[3] = [".code.tio", "JC", "7C", "5D", "8C", "AC", "TC", "9C", "5S"]; // => true
$argb[4] = [".code.tio", ]; // => false
$argb[5] = [".code.tio", "AS", "2S", "3S"]; // => false
$argb[6] = [".code.tio", "JC", "QC", "KC", "AC", "2C"]; // => false
$argb[7] = [".code.tio", "TC", "JC", "QC", "KC", "AC", "2C"]; // => true
$argb[8] = [".code.tio", "2H", "3H", "4H", "5H", "6H", "7H"]; // => true

for ($z=0; $z<9;$z++){
    $argv=$argb[$z];
    array_shift($argv);
    unset($a,$b,$c,$d,$e,$f,$g,$h,$i);
    $f=false; // not needed, just removes several notices

    // TIO code here

    echo "<br>";

TIO कोड

for($b=count($a=$argv);$b;){$a[0]='1X';$a[--$b]=strtr($a[$b],'ATJQK','1:;<=');$a[]=($a[$b][0]==1?">".$a[$b][1]:1);}asort($a);foreach($a as$c){$d[$c[1]][]=$c[0];}foreach($d as$e){if(4<$g=count($e)){for($h=0;$g>$i=4+$h;){$f|=(ord($e[$i])-ord($e[$h++])==4);}}}echo$f;

इसे ऑनलाइन आज़माएं!

— सैम डीन
स्रोत

0

कोटलिन , 226 बाइट्स

10 के लिए प्रयुक्त टी इसलिए सभी कार्ड की लंबाई 2 वर्ण है।

{h:List<String>->val m=List(4){mutableSetOf<Int>()}
for(c in h)m["CDHS".indexOf(c[1])].add("A23456789TJQK".indexOf(c[0]))
var r=0>1
for(b in m){if(b.contains(0))b.add(13)
for(i in 0..9)r=b.containsAll((i..i+4).toList())||r}
r}

इसे ऑनलाइन आज़माएं!

— JohnWells
स्रोत

0

पास्कल (एफपीसी) , 223 216 210 209 बाइट्स

var a,b:char;c:set of byte;i:byte;begin repeat readln(a,b);i:=pos(b,'HDC')*14+pos(a,'23456789TJQK');c:=c+[i];if a='A'then c:=c+[i+13]until eof;i:=0;while not([i..i+4]<=c)or(i mod 14>9)do i:=i+1;write(i<52)end.

इसे ऑनलाइन आज़माएं!

T10. इनपुट के लिए उपयोग में प्रति पंक्ति 1 कार्ड शामिल है।

अब मैंने इसे इतना गोल्फ दिया कि मुझे नहीं पता कि यह अब कैसे काम करता है ...

स्पष्टीकरण:

var a,b:char; //for reading cards
    c:set of byte; //this set is for remembering which cards are present in the input
                   //14 numbers used for each suit
    i:byte;
begin
  repeat
    readln(a,b);             //read rank into a, suit into b and a newline
    i:=pos(b,'HDC')*14+pos(a,'23456789TJQK');
        //temporary use i to calculate corresponding number for the card
        //pos() gives 0 if b is not found
        //1st pos() is for the group of numbers for that suit, 2nd pos() is for offset
    c:=c+[i];                //include i into set
    if a='A'then c:=c+[i+13] //if rank is A, include the number at the end of group as well
  until eof;
  i:=0;
  while not(
    ([i..i+4]<=c) //if NOT 5 cards in a row are present...
    and           //while the check is started from 10 (T)...
    (i mod 14<10) //(otherwise, it is checking across 2 different suits)
  )do i:=i+1;     //increment i, otherwise stop
  write(i<52) //if i<=51, there is a straight flush starting at the card corresponding to i
              //(if there isn't a straight flush, i stops at 252 due to i..i+4, I don't know why)
end.

— AlexRacer
स्रोत

क्या यह एक सीधा फ्लश है?

पायथन 2 , 95 बाइट्स

आर , 128 126 94 91 बाइट्स

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

कैसे?

ब्रेकीलॉग , 31 बाइट्स

रेटिना 0.8.2 , 66 बाइट्स

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

व्याख्या

जावा 10, 189 167 165 164 160 157 156 बाइट्स

क्लीन , 145 135 बाइट्स

जाप , 37 बाइट्स

व्याख्या

जेली , 18 बाइट्स

PHP , 264 बाइट्स

कोटलिन , 226 बाइट्स

पास्कल (एफपीसी) , 223 216 210 209 बाइट्स

स्पष्टीकरण: