^{En relation: Nommez la main de poker}

Une quinte flush est une main de poker contenant cinq cartes de rang séquentiel, toutes de la même couleur. Dans le cadre d'une quinte flush, un as peut se classer au-dessus d'un roi ou en dessous de deux. Un as peut être de rang élevé (par exemple, A ♥ K ♥ Q ♥ J ♥ 10 ♥ est un flush droit à as) ou faible (par exemple 5 ♦ 4 ♦ 3 ♦ 2 ♦ A ♦ est un flush droit à cinq), mais ne peut pas être classé à la fois haut et bas dans la même main (par exemple, Q ♣ K ♣ A ♣ 2 ♣ 3 ♣ est un flush à hauteur d'as, pas un flush droit).

Défi

Les Ncartes données (dans n'importe quel format raisonnable) produisent une valeur vraie si un flush droit est contenu dans la main de poker.

Contribution

• Nnombre de cartes. (Dans tout format raisonnable)

Il y a quatre combinaisons; cœurs, bêches, diamants et massues (H, S, D, C).

Chaque costume a une carte pour les numéros 2 à 10, plus 4 cartes `` photo '', Ace, Jack, Queen et King (A, J, Q, K)

Remarque: vous pouvez prendre 10 comme T

Production

• Truthy/Falsy valeur

Cas de test

["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

Les règles de code-golf standard s'appliquent.

Critères gagnants: Code le plus court dans chaque langue

Python 2 , 95 octets

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

Essayez-le en ligne!

Il y a 40 rinçages droits possibles, et cela les vérifie simplement tous. Chas Brown a économisé 2 octets; Jo King a économisé 4 autres.

R , 128126 94 91 octets

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

Essayez-le en ligne!

La logique originale a été considérablement raccourcie par @ J.Doe.

Donne une matrice de 26 par 26 avec principalement un non-sens, mais toutes les cartes (avec les As répétés en bas) contenues dans les lignes 10 à 23 des colonnes 3, 4, 8 et 24. La matrice est créée en concaténant toutes les combinaisons des majuscules alphabet avec les lettres J à X remplacées par A, 2-9, T, J, Q, K, A, S via chartr. Nous obtenons C, D, H gratuitement!

L' %in%aplatit la matrice colonne par colonne en un vecteur. Vérifiez ensuite si le codage de la longueur d'exécution est supérieur à 4 pour toute série de TRUEcorrespondances.

JavaScript (ES6), 116 octets

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)

Essayez-le en ligne!

Comment?

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

Brachylog , 31 octets

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

Essayez-le en ligne!

 ᵍ                    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"

Retina 0.8.2 , 66 octets

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

Essayez-le en ligne! Explication:

J
11
Q
12
K
13

Convertissez les cartes illustrées en leurs valeurs.

A
1$%'¶14

A peut être 1 ou 14.

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

Convertissez la valeur en unaire et suffixez-la pour que les cartes soient triées correctement.

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

Faites correspondre 5 cartes qui augmentent de 1 à chaque fois et assurez-vous que la dernière augmentation était exactement de 1.

JavaScript (ES6), 106 octets

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)

Accepte un tableau de représentations de chaînes de cartes, en les remplaçant 10par T. Essayez-le en ligne!

Explication

Itère sur chaque carte et définit un indicateur dans un tableau de booléens à l'aide d'un index calculé à partir de la combinaison unique de son rang et de sa couleur. Ce tableau est ensuite stratifié pour permettre de faire correspondre un modèle de 5 valeurs véridiques consécutives.

Par exemple, une main avec un flush droit peut produire ce qui suit comme sous-chaîne de la représentation de chaîne complète du tableau booléen: ,,,,1,1,1,1,1,,,,

Étant donné que la première valeur de rang (c'est-à-dire A) est décalée par rapport au début de la chaîne, il y aura toujours des valeurs vides précédant tous 1les caractères du tableau, garantissant que la représentation de la chaîne commencera par un,

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 ,

Java 10, 189 167 165 165 164 160 157 156 octets

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;}

Prend l'entrée comme une seule chaîne délimitée par des espaces (c'est-à-dire "AS 2S 3S 4S 5S").

-22 octets grâce à @ OlivierGrégoire .
-1 octet grâce à @AlexRacer .

Essayez-le en ligne.

Version golfée du code que j'ai utilisé pour Project Euler # 54 , que j'ai principalement fait avec des expressions régulières (pour le plaisir et pour en savoir plus sur les expressions régulières). Sans regex, cela aurait probablement été meilleur pour les performances et plus facile (s'applique probablement aussi pour jouer au golf cette réponse; nous y reviendrons plus tard).

Explication:

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)

Explication regex supplémentaire:

• "AKQJT98765432A".substring(i,i+5) prend cinq cartes adjacentes basées sur i
• .replaceAll(".","(?=.*$0\\\\1)")remplace chacune de ces cartes par "(?=.*c\\1)"(où cest le caractère de la carte)
• .replaceFirst(".1","([HSDC])")remplacera alors le premier \\1par ([HSDC]).

C'est-à-dire que le regex total pour vérifier le Straight Flush pour les cartes dans la plage de valeurs [9,5]deviendra:
^(?=.*9([HSDC]))(?=.*8\\1)(?=.*7\\1)(?=.*6\\1)(?=.*5\\1).*$
(REMARQUE: String#matchesajoute implicitement le trailing / leader ^...$pour vérifier la chaîne entière.) Ce regex:

^(?=.*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

Nettoyer , 145135 octets

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))==[]]

Essayez-le en ligne!

Simplifié:

? 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
       ]

Japt , 37 octets

Prend l'entrée comme un tableau 2D.

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

Essayez-le

Explication

"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

Gelée , 18 octets

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

Essayez-le en ligne!

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

Format de sortie: liste vide comme fausse, liste non vide comme vraie.

PHP , 264 octets

Il résonne 1s'il s'agit d'une chasse d'eau droite et 0ou nullnon.

Si vous nommez le fichier, 1Xvous pouvez l'enregistrer 11 bytescar vous n'avez pas besoin de le modifier $argv[0]. Je ne sais pas pour l'instant pourquoi le nom de fichier peut le casser.

Pour une raison quelconque, les chaînes :;<=>sont triées avant les chaînes 0123456789par asortdans TIO même si elles :;<=>ont des valeurs ASCII 58-62 et 0123456789des valeurs ASCII 48-57. Donc, si vous prenez le code du lien TIO ou ci-dessous et utilisez PHPTester avec la suite de tests suivante, cela fonctionne.

$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>";

Code 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;

Essayez-le en ligne!

Kotlin , 226 octets

T utilisé pour 10 donc toutes les cartes ont 2 caractères.

{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}

Essayez-le en ligne!

Pascal (FPC) , 223 216 210 209 octets

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.

Essayez-le en ligne!

Utilise Tpour 10. L'entrée contient 1 carte par ligne.

Maintenant je l'ai tellement joué au golf que je ne sais plus comment ça marche ...

Explication:

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.