Đầu vào sẽ là hai từ năm chữ cái. Chúng thực sự không phải là từ trong từ điển, chỉ có năm chữ cái mỗi chữ cái, tất cả chữ thường hoặc chữ hoa, tùy bạn chọn. Chỉ AZ sẽ xuất hiện trong các từ đầu vào và chúng sẽ luôn có độ dài 5 ký tự.

Chương trình của bạn là ghi điểm cho cả hai như thể họ là tay bài xì phé và tay bài cao hơn. Tất nhiên các bộ quần áo sẽ không được áp dụng ở đây, chỉ có thứ hạng để không bị lộn xộn.

Hệ thống xếp hạng poker điển hình bao gồm: '1 cặp', '2 cặp', '3 loại', 'thẳng', 'toàn nhà', '4 loại', '5 loại', và tất nhiên có khả năng bàn tay (hoặc từ trong trường hợp này) có thể không có giá trị gì.

Trong trường hợp quan hệ , các chữ cái gần với A được coi là cao hơn, do đó, một cặp As sẽ đánh bại một cặp Bs. Trong một số trường hợp, cả hai tay có thể giống hệt nhau, nhưng theo một thứ tự khác (hoặc không), trong trường hợp đó, đầu ra hoặc là một phiên bản của bàn tay hoặc một phiên bản của nó.

Trang bên ngoài này chứa thông tin về cách xác định người chiến thắng và đặc biệt là giải quyết các mối quan hệ trong bảng xếp hạng cụ thể, trong trường hợp bạn không quen với cách ghi bàn poker.

Trong trường hợp căng thẳng : các chữ cái phải liền kề trong bảng chữ cái và không được phép quấn quanh. Vì vậy, 'defgh' theo bất kỳ thứ tự nào là thẳng, 'xyzab' thì không.

Ví dụ về cách ghi một bàn tay:

word   | scored as
---------------------
ccccc  | 5 of a kind     <-- highest ranking
woooo  | 4 of a kind
opopo  | full house
vurst  | straight
vovvu  | 3 of a kind
ppoww  | 2 pairs
upper  | 1 pair
kjsdf  | high card only (in this case D) <-- lowest ranking

Vì vậy, chương trình sẽ thực sự tạo ra kết quả như thế này:

input        |  output
-----------------------
voviu,kjsdf  |  voviu     because a pair beats nothing 
opoqo,upper  |  opoqo     because 3 of a kind beats a pair
woooo,ggegg  |  ggegg     because 4 Gs beats 4 Os
queue,hopup  |  queue     because 2 pairs beats 1 pair
lodpl,ddkop  |  ddkop     because pair DD beats pair LL
huhyg,hijht  |  huhyg     both have pair HH, but G beats I
ddffh,ccyyz  |  ccyyz     both have 2 pairs, but CC(yyz) beats DD(ffh)
okaok,nkunk  |  nkunk     KK ties with KK, but NN beats OO
abcdf,bcdef  |  bcdef     because it is a straight
qtery,retyq  |  qtery     identical! so doesnt matter
abedc,vyxwz  |  abedc     because it is a "higher" straight
hhhij,hijkl  |  hijkl     because straight beats 3 of a kind
aaabb,zzzzz  |  zzzzz     because nothing beats 5 of a kind

Thứ tự của các chữ cái trong cả đầu vào và đầu ra là không liên quan, vì vậy thứ tự trong đầu ra của bạn có thể khác với đầu vào, nhưng phải có cùng một kho lưu trữ các chữ cái.

Đầu ra phải chứa chính xác năm chữ cái - không hơn, không kém.

Các quy tắc codegolf thông thường được áp dụng. Mã ngắn nhất sẽ thắng.

JavaScript ( 224 218 213 byte)

s=>t=>(v=s=>(o={},l=n=0,z=3.5,[...s].sort().map(c=>(n+=o[c]=-~o[c],z*=!l|l+1==(l=c.charCodeAt()))),[n+z,Object.keys(o).sort((a,b)=>o[b]-o[a]||(o[b]>o[a]?1:-1))]),w=v(s),x=v(t),w[0]>x[0]||w[0]==x[0]&&w[1]<x[1]?s:t)

Ung dung:

s=>t=>(
  v=s=>(
    o={},
    l=n=0,
    z=3.5,
    [...s].sort().map(c=>(
      n+=o[c]=-~o[c],
      z*=!l|l+1==(l=c.charCodeAt())
    )),
    [n+z,Object.keys(o).sort((a,b)=>o[b]-o[a]||(o[b]>o[a]?1:-1))]
  ),
  w=v(s),x=v(t),
  w[0]>x[0] || w[0]==x[0] && w[1]<x[1] ? s : t
)

Sau khi map()chạy, n + zxác định thứ hạng của một bàn tay:

(Bạn có thể hiểu lý do tại sao tôi khởi tạo zlên 3.5.)

Trong trường hợp hòa, Object.keys(o).sort()được sử dụng để xác định tay xếp hạng cao hơn.

Đoạn trích:

f=

s=>t=>(v=s=>(o={},l=n=0,z=3.5,[...s].sort().map(c=>(n+=o[c]=-~o[c],z*=!l|l+1==(l=c.charCodeAt()))),[n+z,Object.keys(o).sort((a,b)=>o[b]-o[a]||(o[b]>o[a]?1:-1))]),w=v(s),x=v(t),w[0]>x[0]||w[0]==x[0]&&w[1]<x[1]?s:t)

console.log(/voviu/.test(f('voviu')('kjsdf')))       //because a pair beats nothing 
console.log(/opoqo/.test(f('opoqo')('upper')))       //because 3 of a kind beats a pair
console.log(/ggegg/.test(f('woooo')('ggegg')))       //because 4 Gs beats 4 Os
console.log(/queue/.test(f('queue')('hopup')))       //because 2 pairs beats 1 pair
console.log(/ddkop/.test(f('lodpl')('ddkop')))       //because pair DD beats pair LL
console.log(/huhyg/.test(f('huhyg')('hijht')))       //both have pair HH, but G beats I
console.log(/ccyyz/.test(f('ddffh')('ccyyz')))       //both have 2 pairs, but CC(yyz) beats DD(ffh)
console.log(/nkunk/.test(f('okaok')('nkunk')))       //KK ties with KK, but NN beats OO
console.log(/bcdef/.test(f('abcdf')('bcdef')))       //because it is a straight
console.log(/qtery|retyq/.test(f('qtery')('retyq'))) //identical! so doesnt matter
console.log(/abedc/.test(f('abedc')('vyxwz')))       //because it is a "higher" straight
console.log(/hijkl/.test(f('hhhij')('hijkl')))       //because straight beats 3 of a kind
console.log(/zzzzz/.test(f('aaabb')('zzzzz')))       //because nothing beats 5 of a kind

Thạch ,  28 27 29  27 byte

+2 và sau đó -2 sửa một lỗi, sau đó chơi lại gôn.

FI=1ȦḤW
OµNĠLÞṚịµL€+Ç,N
ÇÞṪ

Một liên kết đơn âm lấy một danh sách "tay" và trả lại (một trong) những người chiến thắng.

Hoạt động cho tất cả chữ hoa hoặc đầu vào chữ thường.
(... Nhưng không trộn lẫn, vì điều đó hãy đặt trước dòng cuối cùng bằng Œlhoặc Œu).

Hãy thử trực tuyến! hoặc xem bộ thử nghiệm .

Làm sao?

FI=1ȦḤW - Link 1, straight offset: grouped and reverse sorted hand ordinals
        -                     e.g. [[-101],[-100],[-99],[-98],[-97]]
F       - flatten                  [-101,-100,-99,-98,-97]
 I      - increments               [1,1,1,1]
  =1    - equal 1? (vectorises)    [1,1,1,1]
    Ȧ   - any and all?             1
     Ḥ  - double                   2
      W - wrap in a list           [2]
        -   The purpose of this is so that when "a" from Link 2 represents a straight we
        -   get [2], whereas for any other hand we get [0]. Adding the [2] to [1,1,1,1,1]
        -   (the lengths of a straight's groups) yields [3,1,1,1,1], placing it between
        -   three of a kind, [3,1,1], and a full house, [3,2], as required.

OµNĠLÞṚịµL€+Ç,N - Link 2, hand rank key function: list of characters       e.g. "huhyg"
O               - cast to ordinals                                [104,117,104,121,103]
 µ              - monadic chain separation, call that o
  N             - negate (to give them a reverse-sort order) [-104,-117,-104,-121,-103]
   Ġ            - group indices by value                            [[4],[2],[1,3],[5]]
     Þ          - sort by key function:
    L           -   length                                          [[4],[2],[5],[1,3]]
      Ṛ         - reverse                                           [[1,3],[5],[2],[4]]
       ị        - index into o                       [[-104,-104],[-103],[-117],[-121]]
        µ       - monadic chain separation (call that a)
         L€     - length of €ach                                              [2,1,1,1]
            Ç   - call last link (2) as a monad -> [isStraight? * 2]                [0]
           +    - addition (vectorises)                                       [2,1,1,1]
              N - negate o                                [[104,104],[103],[117],[121]]
             ,  - pair                        [[2,1,1,1],[[104,104],[103],[117],[121]]]
                -   now sorting by this will first be comparing the hand class, and if
                -   and only if they match comparing the card values in the required order.

ÇÞḢ - Main link: list of lists of characters (list of hands)
 Þ  - sort by key function:
Ç   -   last link (2) as a monad
  Ṫ - tail (best or an equal-best hand)

JavaScript ( 250 247 232 byte)

S=d=>(x={},l=99,h=s=0,[...d].map(v=>x[v]=-~x[v]),Object.keys(x).map(v=>(c=91-v.charCodeAt(),t=x[v],s+=1e4**t,c<x[t]?0:x[t]=c,g=(h=c>h?c:h)-(l=c<l?c:l))),[5,4,3,2,1].map(v=>s+=0|x[v]**v),s+(s<5e7&&g<5?1e13:0)),C=a=>b=>(S(a)>S(b)?a:b)

Các trường hợp kiểm tra và mã bị lỗi trong JSFiddle: https://jsfiddle.net/CookieJon/8yq8ow1b/

Đã lưu một số byte nhờ vào @RickHitchcock. @StephenS & @Arnauld

Python 2.7, 242 223 byte

from collections import*
s=sorted
f=lambda x,y:s(map(lambda h:(lambda (r,n):((3,1.5)if len(r)==5 and ord(r[0])+4==ord(r[4])else n,[-ord(d) for d in r],h))(zip(*s(Counter(h).items(),key=lambda z:(-z[1],z[0])))),(x,y)))[1][2]

Tương tự trong khái niệm cơ bản với các ví dụ javascript (sắp xếp theo độ mạnh tay với ngoại lệ cho các mức độ căng thẳng; sau đó theo thứ hạng); nhưng lợi dụng collections.CounterThật không may, .most_commonkhông có hành vi mong muốn; vì vậy phải thêm một khóa sắp xếp tùy chỉnh.

Chỉnh sửa: thêm một chút mã golf để cắt giảm 19 byte.

Mã không chơi gôn

from collections import Counter

def convertHand(h):
    # first get item counts, appropriately ordered; e.g. cbabc -> (('b',2), ('c',2),('a',1))
    sortedPairs = sorted(Counter(h).items(),key=lambda x:(-x[1],x[0]))

    # 'unzip' the tuples to get (('b','c','a'), (2,2,1))
    ranks, numberFound = zip(*sortedPairs) 

    if len(ranks)==5:
        # no pairs; is it a straight? well, since they are in increasing order...
        if ord(ranks[0])+4 == ord(ranks[4]):
            # replace numberFound with something that will sort above 3 of a kind but below full house
            numberFound = (3,1.5)

    # invert the values of the ranks, so they are in decreasing, rather then increasing order
    ranks = [-ord(r) for r in ranks]

    # arrange tuples so we can sort by numberFound, and then ranks; and keep a reference to the hand
    return (numberFound, ranks, h)

# put it all together...
def f(x,y):
    hands = [convertHand(h) for h in (x,y)]
    rankedHands = sorted(hands)
    return rankedHands[1][2]

Toán học, 635 byte

H[x_]:=Block[{t},T=Sort@ToCharacterCode[x];L=Last/@Tally@T;t=0;S=Count;If[S[L,2]==1,t=1];If[S[L,2]==2,t=2];If[S[L,3]==1,t=3];If[S[Differences@T,1]==4,t=4];If[S[L,2]==1&&S[L,3]==1,t=5];If[S[L,4]==1,t=6];If[S[L,5]==1,t=7];t];F[K_,v_]:=First@Flatten@Cases[Tally@K,{_,v}];B=ToCharacterCode;(Z=Sort@B@#1;Y=Sort@B@#2;a=H[#1];b=H[#2];If[a>b,P@#1,If[a<b,P@#2]]If[a==b&&a==0,If[Z[[1]]<Y[[1]],P@#1,P@#2]];If[a==b&&(a==1||a==2),If[F[Z,2]<F[Y,2],P@#1,If[F[Z,2]==F[Y,2],If[F[Z,1]<F[Y,1],P@#1,P@#2],P@#2]]];If[a==b&&(a==3||a==5),If[F[Z,3]<F[Y,3],P@#1,P@#2]];If[a==b&&a==6,If[F[Z,4]<F[Y,4],P@#1,P@#2]];If[a==b&&(a==7||a==4),If[Tr@Z<Tr@Y,P@#1,P@#2]])&

.
.
Mẫu đầu vào

["abcde", "kkekk"]