^{이 도전에서 영감을 얻어 이것 과 관련 이 있습니다.}

배경

Badugi [bæduːɡiː]는 로우 볼 드로우 포커 변형입니다.

^{Pokerstars World Cup Of Online Poker $ 1K 이벤트는 3 시간 이내에 시작 되며 내 손이 얼마나 좋은지 알아야합니다!}

이 게임은 4 개의 슈트와 13 개의 랭크로 구성된 52 장의 표준 데크를 사용합니다 . 소송은 비 순차적이며 표시되어야한다 cdhs. 순위 - 최고에서 정렬 K가장 낮은에이 A-입니다 KQJT98765432A. 따라서 전체 데크는 다음과 같이 표시 될 수 있습니다 (공백 구분).

Kc Kd Kh Ks Qc Qd Qh Qs Jc Jd Jh Js Tc Td Th Ts 9c 9d 9h 9s 8c 8d 8h 8s 7c 7d 7h 7s 6c 6d 6h 6s 5c 5d 5h 5s 4c 4d 4h 4s 3c 3d 3h 3s 2c 2d 2h 2s Ac Ad Ah As 

각 플레이어는 덱에서 4 장의 카드를받습니다. 그 사이에 3 개의 라운드가있는 4 개의 베팅 라운드가 있습니다. 세 가지 그림 라운드 중 하나).

이 모든 라운드 후에도 한 명 이상의 선수가 활동중인 경우 대결이 진행되며, 가장 강한 패가 베팅에서 승리합니다.

게임은 로우 볼로 플레이되므로 가장 낮은 핸드가 이기고 위에서 언급 한 바와 같이 A(에이스) 낮습니다. 또한 핸드 랭킹은 다른 형태의 포커와 다르며 초보자에게는 다소 혼란 스러울 수 있습니다.

플레이 한 "핸드"는 4 개의 홀드 카드에서 가능한 "off-suit"(모든 다른 슈트) 및 "off-rank"(모든 다른-랭크) 카드 중에서 가장 높은 수의 조합에서 가장 낮은 순위의 조합입니다. ). 즉, 만약 한 사람이 서로 다른 수트 를 가진 4 장의 카드 와 다른 등급을 가진다면 , 4 장의 카드 패 ( "badugi"라고 함)가 있습니다. 만약 한 사람이 4 장의 카드 패를 가지고 있지 않지만 별개의 수트 와 별개의 순위를 가진 3 장의 카드 세트 또는 세트를 가지고 있다면 1 장의 카드는 3 장의 카드 패를가집니다 (하나는 최고를 선택합니다). 만약 한 사람이 4 장의 카드 패나 3 장의 카드 패를 가지고 있지 않다면 아마도 2 장의 카드 패를 가지고있을 것입니다.

• 따라서 가장 좋은 핸드는 4 장의 카드 패 입니다. 4 개의 다른 종류4-3-2-A 의 가장 낮은 등급의 카드는 종종 "숫자 -1"이라고 불립니다. 가장 약한 손은 1 장의 손 이며 정확히 잡고 있어야만 가능합니다 .KKc Kd Kh Ks

• 참고 4c 3h 2c As입니다 하지 때문에, "수-1" 4c과 2c같은 무늬의, 그러나 그것은 이다 3 카드 손의 최강, 3-2-A그것은 다른 무승부 3-2-1(같은 S Kh 3d 2s Ah) 및 기타 모든 3 카드 손을 뛰고 있지만, 모든 4 장의 패를 잃습니다 (만큼 약할 수 있음 K-Q-J-T).

  • 만들 수있는 다른 3 장의 카드 핸드 4c 3h 2c As는입니다 4-3-A. 그러나 더 약합니다 (더 높음).

• 마찬가지로 8d 6h 3s 2h3 장의 패가 있습니다.-3의 8-3-2오프 랭크 오프-슈트 조합이 2 개 있으며 3 개 (또는 "트레이")가 6 개보다 낮기 때문에 8-3-2(낮음) 더 좋습니다 8-6-3.

손을 서로 비교하는 것은 동일한 논리를 따릅니다 .4 카드는 3 카드를, 3 카드는 2 카드를, 2 카드는 1 카드를칩니다. (예 : 가장 낮은에 가장 높은 순위 아래에서 비교 8-4-2비트 8-5-A가 아니라 어떤의 8-4-A, 8-3-2또는 7-6-5)

도전 과제 :

4 장의 카드 각각에 2 개의 비 순서 수집이 주어지면, Badugi 대결에서이기는 카드를 확인하십시오 (무승부인지 모두 확인).

입력은 합리적 일 수 있습니다.

• 왼쪽 4 개는 한 손으로, 오른쪽 4 개는 선택적인 구분 기호를 사용하여 위에 (공백이 있거나없는) 8 개의 카드 모두의 단일 문자열; 또는 같은 방식으로 문자 목록
• 두 줄의 목록-한 손에 하나씩 또는 같은 방식으로 문자 목록
• 두 개의 개별 문자열 또는 목록 입력 (한 손에 하나씩)
• 손 안에있는 카드도 이미 분리되어있을 수 있습니다 (따라서 목록 목록은 괜찮습니다)

그러나 다음 사항에 유의하십시오.

• 카드는 입력 전에 어떤 순서로도 배열 될 수 없습니다
• ... 및 소송과 순위는 여기에 지정된 문자 레이블로 고정되어 있습니다. 언어가 그러한 구성을 지원하지 않는 경우 합리적인 것을 제안하고 언어 제약 조건에 따라 적절한 대안인지 묻습니다.

출력은

• 입력과 동일하게 형식화되거나 인쇄 된 표현; 또는
• (: 세 가지 예와 일관된 결과 중 하나가 "left", "right", "both"또는 1, 2, 3, 등)

실제로-두 입력 중 어느 것이 식별되고 있는지 분명한 한 괜찮습니다.

테스트 사례

input                      ->  output
                                   (notes)
----------------------------------------------------------------------------
3c 2s 4d Ah - As 3h 2d 4h  ->  3c 2s 4d Ah
                                   (4-card 4-3-2-A beats 3-card 3-2-A)

3c 2s 4d Ah - As 2c 3d 4h  ->  3c 2s 4d Ah - As 2c 3d 4h
                                   (4-card 4-3-2-A draws with 4-card 4-3-2-A)

2d Ac 4h 3c - Kh Ad 9s 2c  ->  Kh Ad 9s 2c
                                   (3-card 4-2-A loses to 4-card K-9-2-A)

Kc Tc Qc Jc - Ac Ad Ah As  ->  Ac Ad Ah As
                                   (1-card T loses to 1-card A)

9c 9h Qc Qh - Qs Kh Jh Kd  ->  Qs Kh Jh Kd
                                   (2-card Q-9 loses to 3-card K-Q-J)

2d 5h 7c 5s - 2h 3c 8d 6c  ->  2d 5h 7c 5s
                                   (3-card 7-5-2 beats 3-card 8-3-2)

3s 6c 2d Js - 6h Jd 3c 2s  ->  6h Jd 3c 2s
                                   (3-card 6-3-2 loses to 4-card J-6-3-2)

Ah 6d 4d Ac - 3h 2c 3s 2s  ->  3h 2c 3s 2s
                                   (2-card 4-A loses to 2-card 3-2)

2h 8h 6h 4h - 6d 2d 5d 8d  ->  2h 8h 6h 4h - 6d 2d 5d 8d
                                   (1-card 2 = 1-card 2)

이것은 코드 골프따라서 바이트 단위의 가장 짧은 코드는 언어별로 이기고 가장 짧은 코드는 전체적으로 이깁니다. 골프 언어로 인해 다른 언어로 제출하지 못하게하고 재미있게 보내십시오!

펄 6 , 128 바이트

{.map({.combinations(1..4).grep({!.join.comb.repeated}).map({-$_,$_».trans('ATK'=>'1BZ')».ord.sort(-*)}).min}).minpairs».key}

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

문자열과 같은 카드 목록 인 손 목록 (둘 이상)을 가져옵니다 Kc. 가장 낮은 점수를 가진 손의 인덱스를 반환합니다. 양손의 (0)경우 첫 번째 핸드가 이기고 (1)두 번째 핸드가 이기면 (0, 1)무승부입니다.

설명 :

{
    # Map hands to best "played hand".
    .map({
        # Generate all combinations of length 1 to 4.
        .combinations(1..4)
        # Remove hands with repeated characters.
        .grep({!.join.comb.repeated})
        # Map to a cmp-arable representation. This works because
        # lists are compared element-wise. Translate some characters
        # so that ASCII order works. Sort in reverse order so that
        # element-wise comparison will go from highest to lowest.
        .map({ -$_, $_».trans('ATK'=>'1BZ')».ord.sort(-*) })
        # Find best hand.
        .min
    })
    # Return indices of lowest scoring hands. It's a shame that
    # `minpairs` doesn't support a filter like `min`.
    .minpairs».key
}

자바 스크립트 (ES6) 209 202 192 182 181 바이트

@Neil 덕분에 7 바이트 절약

입력을 문자열 배열의 배열로 가져옵니다. true첫 번째 핸드가 이길 false경우, 두 번째 핸드가이기거나 2넥타이 인 경우를 반환 합니다 .

a=>([a,b]=a.map(a=>a.reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).map(a=>!/(\w).*\1/.test(a)*a.length+a.map(a=>'KQJT98765432A'.search(a[0])+10).sort()).sort().pop()),a==b?2:a>b)

테스트 사례

let f =

a=>([a,b]=a.map(a=>a.reduce((a,x)=>[...a,...a.map(y=>[x,...y])],[[]]).map(a=>!/(\w).*\1/.test(a)*a.length+a.map(a=>'KQJT98765432A'.search(a[0])+10).sort()).sort().pop()),a==b?2:a>b)

console.log(f([["3c","2s","4d","Ah"], ["As","3h","2d","4h"]])) // true  (1st hand wins)
console.log(f([["3c","2s","4d","Ah"], ["As","2c","3d","4h"]])) // 2     (tie)
console.log(f([["2d","Ac","4h","3c"], ["Kh","Ad","9s","2c"]])) // false (2nd hand wins)
console.log(f([["Kc","Tc","Qc","Jc"], ["Ac","Ad","Ah","As"]])) // false (2nd hand wins)
console.log(f([["9c","9h","Qc","Qh"], ["Qs","Kh","Jh","Kd"]])) // false (2nd hand wins)
console.log(f([["2d","5h","7c","5s"], ["2h","3c","8d","6c"]])) // true  (1st hand wins)
console.log(f([["3s","6c","2d","Js"], ["6h","Jd","3c","2s"]])) // false (2nd hand wins)
console.log(f([["Ah","6d","4d","Ac"], ["3h","2c","3s","2s"]])) // false (2nd hand wins)
console.log(f([["2h","8h","6h","4h"], ["6d","2d","5d","8d"]])) // 2     (tie)

어떻게?

a => (
  // store the best combination for both hands in a and b respectively
  [a, b] = a.map(a =>
    // compute the powerset of the hand
    a.reduce((a, x) => [...a, ...a.map(y => [x, ...y])], [[]])
    // for each entry:
    .map(a =>
      // invalidate entries that have at least 2 cards of same rank or same value
      !/(\w).*\1/.test(a) *
      // the score of valid entries is based on their length ...
      a.length +
      // ... and their card values, from highest to lowest
      // (we map 'KQJT98765432A' to [10 - 22], so that the resulting
      // strings can be safely sorted in lexicographical order)
      a.map(a => 'KQJT98765432A'.search(a[0]) + 10).sort()
    )
    // keep the best one
    .sort().pop()
  ),
  // compare a with b
  a == b ? 2 : a > b
)

젤리 , 36 바이트

ẎŒQȦ;L;Ṗ€Ṣ$
“A+KYTE”yḲONŒPÇ€ṢṪµ€⁼€Ṁ$

문자의 두 목록의 목록 복용 모나드 링크
- 각각의 공간 인은 손의 표현 (예를 들어 분리 "Ac 2d 4s 3h")
와 우승자 (들)을 확인하는 두 숫자의 목록을 반환 1하고 어떤 패자가 0
- 즉 [1, 0]승리를 왼쪽 =을; [0, 1]= 오른쪽 승리; [1, 1]= 무승부.

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

ẎŒQȦ;L;Ṗ€Ṣ$ - Link 1, sortKey: list of lists of numbers representing some cards (see Main)
Ẏ           - flatten into a single list of numbers
 ŒQ         - distinct sieve (1 at first occurrence of anything, 0 at the rest)
   Ȧ        - Any & All? zero if any are 0 or if empty; 1 otherwise (i.e. playable hand?)
     L      - length of input (number of cards in the hand)
    ;       - concatenate
          $ - last two links as a monad:
       Ṗ€   -   pop each (get just the rank portions)
         Ṣ  -   sort (Main's translation & negation of ordinals ensures A>2>3>...>Q>K)
      ;     - concatenate (now we have [isPlayable; nCards; [lowToHighCards]])

“A+KYTE”yḲONŒPÇ€ṢṪµ€⁼€Ṁ$ - Main link: list of lists of characters, hands
                  µ€     - for €ach of the two hands:
“A+KYTE”                 -   literal list of characters "A+KYTE" (compressing doesn't help - lower case would be “£Ḅṁ⁽>» though -- I'll stick with kyte though it's kind of nice.)
        y                -   translate - change As to +s, Ks to Ys and Ts to Es
                         -               note the ranks are now in ordinal order:
                         -               +<2<3<4<5<6<7<8<9<E<J<Q<Y
         Ḳ               -   split at spaces - split the four cards up
          O              -   to ordinals '+'->43, '2'->50, ...
           N             -   negate - effectively reverse the ordering
            ŒP           -   power-set - get all combinations of 0 to 4 cards inclusive
              Ç€         -   call the last link (1) as a monad for €ach such selection
                Ṣ        -   sort these keys
                 Ṫ       -   tail - get (one of) the maximal keys
                         -                       (the key of a best, playable selection)
                       $ - last two links as a monad:
                      Ṁ  -   maximum (the better of the two best, playable selection keys)
                    ⁼€   -   equals? for €ach (1 if the hand is a winner, 0 if not)

파이썬 3 , 207204 바이트

lambda i,j:L(h(i))-L(h(j))if L(h(i))!=L(h(j))else(h(i)<h(j))-(h(i)>h(j))
L=len
def h(l):s=set();return[x[0]for x in sorted(y.translate({65:49,75:90,84:65})for y in l)if not(s&set(x)or s.update(*x))][::-1]

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

Jonathan Frech 덕분에 3 바이트 절약

1초침이 이길 -1경우, 초침이 이길 0경우 그리고 추첨의 경우를 반환 합니다 .

이 함수 h는 손을 나타내는 목록을 계산합니다.

람다는 손의 두 가지 표현을 비교합니다. 나는 그것이 단축 될 수 있다고 생각하지만 세 가지 값 만 반환하고 싶고 비교를 수행하는 더 간단한 방법을 찾지 못했습니다.