^{관련 : 포커 핸드 이름 지정}

스트레이트 플러시는 연속 순위의 5 장의 카드를 모두 포함하는 포커 핸드입니다. 스트레이트 플러시의 일부로 에이스는 왕 이상 또는 2 이하로 순위를 매길 수 있습니다. 에이스는 높음 (예 : A ♥ K ♥ Q ♥ J ♥ 10 ♥은 에이스-높은 스트레이트 플러시) 또는 낮음 (예 : 5 ♦ 4 ♦ 3 ♦ 2 ♦ A ♦는 5- 높은 스트레이트 플러시) 중 하나입니다. 같은 손으로 높거나 낮게 순위를 매길 수 없습니다 (예 : Q ♣ 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

표준 코드 골프 규칙이 적용됩니다.

승리 기준 : 각 언어에서 가장 짧은 코드

파이썬 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 가지의 가능한 스트레이트 플러시가 있으며 이는 단순히 모두 플러시합니다. Chas Brown은 2 바이트를 절약했습니다. Jo King은 4 개를 더 절약했습니다.

R , 128126 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에 의해 원래의 논리가 상당히 단축되었습니다.

3,4,8, 24 열의 10 ~ 23 행에 대부분 넌센스이지만 모든 카드 (하단에 Ace가 반복됨)를 가진 26 x 26 행렬을 만듭니다. 행렬은 대문자의 모든 조합을 연결하여 만들어집니다 문자 J부터 X까지의 알파벳을 통해 A, 2-9, T, J, Q, K, A, S로 대체됩니다 chartr. 우리는 C, D, H를 무료로받습니다!

는 %in%벡터로 열 방향으로 매트릭스를 병합. 그런 다음 TRUE일치 하는 실행에 대해 실행 길이 인코딩이 4보다 큰지 확인하십시오 .

자바 스크립트 (ES6), 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)

온라인으로 사용해보십시오!

방법?

각각의 슈트를 들어 , 우리는 모든 카드 변환 소송의 14 비트 비트 마스크로 핸들을 중복 비트 # 13 (에이스) 비트 # 0, 스틸 휠 (A, 2,3,4,5)와 수를 연속 비트 수 4보다 크면 스트레이트 플러시입니다.c s $s$$c$$s$$m$

Brachylog , 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"

레티 나 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인지 확인하십시오.

자바 스크립트 (ES6), 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. 온라인으로 사용해보십시오!

설명

각 카드를 반복하고 순위와 수트의 고유 한 조합에서 계산 된 색인을 사용하여 부울 배열로 플래그를 설정합니다. 그런 다음이 배열은 5 개의 연속 된 정확한 값의 패턴을 일치시킬 수 있도록 문자열 화됩니다.

예를 들어, 스트레이트 플러시가있는 손은 다음을 부울 배열의 전체 문자열 표현의 하위 문자열로 생성 할 수 있습니다. ,,,,1,1,1,1,1,,,,

첫 번째 순위 값 (예 : A)은 문자열의 시작 부분에서 오프셋 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 ,

자바 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".

@ OlivierGrégoire 덕분에 -22 바이트 . @AlexRacer
덕분에 -1 바이트 .

온라인으로 사용해보십시오.

의 Golfed 버전 내가 사용했다고 코드 에 대한 프로젝트 오일러 # 54 내가 주로 정규 표현식에 함께했던 (재미와 정규 표현식에 대해 더 배울 수). 정규 표현식이 없으면 성능이 향상되고 쉬울 것입니다 (아마도이 ​​답변을 골프에 적용 할 수 있습니다. 나중에 살펴볼 것입니다).

설명:

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) 5 장의 인접 카드를받습니다 i
• .replaceAll(".","(?=.*$0\\\\1)")각 카드를 "(?=.*c\\1)"( c카드 문자가있는 곳 )으로 바꿉니다.
• .replaceFirst(".1","([HSDC])")다음 첫 번째 대체 할 \\1과를 ([HSDC]).

값 범위에서 카드의 스트레이트 플러시를 확인하기 위해 전체 정규식 IE [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

클린 , 145135 바이트

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
       ]

apt , 37 바이트

입력을 2D 배열로 취합니다.

"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

젤리 , 18 바이트

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

온라인으로 사용해보십시오!

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

출력 형식 : 빈 목록은 허위로, 비어 있지 않은 목록은 사실로 표시합니다.

PHP , 264 바이트

그것은 메아리 1가 스트레이트 플러시하고있는 경우 0또는 null그렇지 않은 경우.

파일 이름을 지정하면 변경할 필요가 없으므로 1X저장할 수 11 bytes있습니다 $argv[0]. 왜 파일 이름이 파일을 손상시킬 수 있는지 확실하지 않습니다.

어떤 이유로 문자열은 :;<=>문자열 전에 정리 될 0123456789하여 asort비록 TIO에서 :;<=>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;

온라인으로 사용해보십시오!

코 틀린 , 226 바이트

모든 카드의 길이가 2 자이므로 10을 T로 사용했습니다.

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

온라인으로 사용해보십시오!

파스칼 (FPC) , 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.