Các thách thức:

Trong câu hỏi này: Đặt tên cho tay bài xì phé bạn phải lấy một ván bài năm lá và xác định nó. Câu hỏi này tương tự, với hai vòng xoắn:

Đầu tiên, đầu ra sẽ ở tất cả các trường hợp thấp hơn. Điều này cho phép chơi gôn nhiều hơn, vì bạn không phải lo lắng về việc viết hoa flushvàstraight

high card
one pair
two pair
three of a kind
straight
flush
full house
four of a kind
straight flush
royal flush

Thứ hai, với sự phổ biến của Texas Hold'em và 7 lá bài stud, chúng tôi ở đây tại môn đánh gôn có thể ghi được bảy ván bài xì phé đúng không? Khi ghi một tay bảy thẻ, hãy sử dụng năm thẻ tốt nhất cho tay của bạn và bỏ qua hai thẻ bạn không cần.

Tài liệu tham khảo:

Danh sách các tay bài xì phé: http://en.wikipedia.org/wiki/List_of_poker_hands

Đầu vào (nâng trực tiếp từ luồng trước)

7 thẻ từ đối số stdin hoặc dòng lệnh. Thẻ là một chuỗi hai chữ cái trên biểu mẫu RS, trong đó R là xếp hạng và S là phù hợp. Các cấp bậc là 2- 9(thẻ số), T(mười), J(Jack), Q(Nữ hoàng), K(Vua), A(Ace). Các bộ quần áo là S, D, H, Ccho Spades, kim cương, trái tim và các câu lạc bộ tương ứng.

Ví dụ về thẻ

5H - five of hearts
TS - ten of spades
AD - ace of diamonds

Ví dụ về đầu vào => đầu ra mong muốn

3H 5D JS 3C 7C AH QS => one pair
JH 4C 2C 9S 4H JD 2H => two pair
7H 3S 7S 7D AC QH 7C => four of a kind
8C 3H 8S 8H 3S 2C 5D => full house
AS KC KD KH QH TS JC => straight

Lưu ý trong ví dụ thứ hai thực sự có ba cặp, nhưng bạn chỉ có thể sử dụng năm thẻ, vì vậy nó two pair. Trong ví dụ thứ năm, có cả a three of a kindvà a straightcó thể, nhưng a straightlà tốt hơn, vì vậy đầu ra straight.

Chấm điểm

Đây là mã golf , vì vậy mã ngắn nhất sẽ thắng!

Errata

1. Bạn không thể sử dụng tài nguyên bên ngoài.
2. Ace là cả cao và thấp cho căng thẳng.

Hồng ngọc 353

Điều này được dựa trên câu trả lời của Chron từ câu hỏi ban đầu.

Điều này nhận đầu vào là đối số dòng lệnh. Về cơ bản, chúng tôi chỉ lặp đi lặp lại trên tất cả các kết hợp của kích thước 5 để có được kiểu tay nào. Mỗi loại tay đã được sửa đổi để bắt đầu bằng một số. ("tuôn ra hoàng gia" -> "0royal 4flush", "thẻ cao" -> "thẻ cao 9"). Điều này cho phép chúng tôi sắp xếp các chuỗi đã được trả lại. Chuỗi đầu tiên sau khi sắp xếp là bàn tay tốt nhất có thể. Vì vậy, chúng tôi in rằng sau khi loại bỏ tất cả các số từ chuỗi.

o,p=%w(4flush 1straight)
f=/1{5}|1{4}0+1$/
puts $*.combination(5).map{|z|s=[0]*13;Hash[*z.map{|c|s['23456789TJQKA'.index c[0]]+=1;c[1]}.uniq[1]?[f,'5'+p,?4,'2four'+a=' of a kind',/3.*2|2.*3/,'3full house',?3,'6three'+a,/2.*2/,'7two pair',?2,'8one pair',0,'9high card']:[/1{5}$/,'0royal '+o,f,p+' '+o,0,o]].find{|r,y|s.join[r]}[1]}.sort[0].gsub(/\d/,'')

Haskell 618 603 598 525 512 504 480 464

Thẻ được lấy làm một dòng đầu vào. Tôi nghĩ rằng tôi đã đánh golf này đến chết, nhưng sẽ dễ dàng bị đánh bại bởi ruby, v.v ... bằng cách sử dụng cùng một mẹo: nếu bạn tạo ra tất cả các hoán vị, bạn sẽ có được các loại chuyển tiếp bạn muốn tìm kiếm sức căng, cộng với các loại đảo ngược mà bạn muốn kiểm tra N của một loại.

import Data.List
m=map
z=take 5
q=m(\x->head[n|(f,n)<-zip"A23456789TJQK"[1..],f==x!!0])
l=m length
v=" of a kind"
w="flush"
y="straight"
c f s p r|f&&r="9royal "++w|f&&s='8':y++" "++w|f='5':w|s||r='4':y|True=case p of 4:_->"7four"++v;3:2:_->"6full house";3:_->"3three"++v;2:2:_->"2two pair";2:_->"1one pair";_->"0high card"
d x=c([5]==l(group$m(!!1)x))(q x==z[head(q x)..])(l$group$q x)$q x==1:[10..13]
k h=tail$maximum$m(d.z)$permutations$words h
main=interact k

Đã chỉnh sửa thành "cặp" nội tuyến và sử dụng tiền tố số sau khi thấy mục nhập của @ FDinoff, cũng bao gồm các chức năng bản đồ để cạo thêm một char.

C ++, 622 553 ký tự

bốn dòng mới không cần thiết được thêm vào dưới đây cho rõ ràng.

#include"stdafx.h"
#include"string"
std::string c=" flush",d=" of a kind",e="straight",z[10]={"high card","one pair","two pair","three"+d,e,c,"full house","four"+d,e+c,"royal"+c},
x="CDHSA23456789TJQK";char h[99];int main(){__int64 f,p,t,g,u,v,w,l=1,a=78517370881,b=a+19173960,i,j,q=0;gets_s(h,99);for(i=28;i-->7;){f=p=0;
for(j=7;j--;)if(j!=i%7&j!=(i+i/7)%7){f+=l<<x.find(h[j*3+1])*6;p+=l<<x.find(h[j*3])*3-12;}
v=p&b*2;u=v&v-1;w=p&p/2;g=p*64&p*8&p&p/8&p/64;f&=f*4;t=f&&p==a?9:f&&g?8:p&b*4?7:u&&w?6:f?5:g||p==a?4:w?3:u?2:v?1:0;
q=t>q?t:q;}puts(z[q].c_str());}

Mọi thứ đã thay đổi trong phiên bản chơi gôn:

Rev 1: Thay đổi tất cả các biến số thành __int64khai báo đơn.

Rev 1: Gia tăng đánh gôn và tình trạng của forcác vòng lặp

Rev 0: Hằng số bát phân thay đổi thành số thập phân.

Rev 0: Thay đổi các ifcâu lệnh thành các bài tập với toán tử có điều kiện. Rev 1: Bố trí lại thêm vào một biểu hiện duy nhất cho t. Điều này yêu cầu biến mới vcho một trong các giá trị trung gian

Rev 0: Đã xóa đầu ra dài dòng. Chỉ đầu ra tay tốt nhất tổng thể.

Rev 0: Tiếp tục nén văn bản đầu ra (khó sử dụng C vì bạn không thể nối chuỗi bằng toán tử +.) Viết "tuôn ra" chỉ một lần giúp tôi tiết kiệm được 12 ký tự nhưng lại khiến tôi mất 3 ký tự. Vì vậy, tôi chỉ viết nó 3 lần thay thế. Rev 1: được sử dụng std::stringthay vì char[]theo đề xuất của FDinoff, giúp có thể kết hợp với +.

Phiên bản Ungolfed, 714 ký tự không phải không gian trống.

Vòng lặp qua tất cả 21 tay có thể được tạo từ 7 thẻ và từ chối 2 thẻ mỗi lần. Sự phù hợp và thứ hạng của năm thẻ được chọn được tính tổng trong các biến f và p với một chữ số bát phân khác nhau cho mỗi bộ đồ / cấp bậc. Các hoạt động bit khác nhau được thực hiện để xác định loại tay, sau đó được lưu trữ trong t (tất cả 21 khả năng là đầu ra trong phiên bản không được chỉnh sửa.) Cuối cùng, bàn tay tốt nhất có thể là đầu ra.

#include "stdafx.h"
#include "string.h"

char x[] = "CDHSA23456789TJQK", h[99], z[10][99] = 
{ "high card", "one pair", "two pair","three of a kind", "straight","flush","full house","four of a kind","straight","royal" };

int main(void)
{
        int i,j,q=0;                  //i,j:loop counters. q:best possible hand of 7 card   
        scanf_s("%s/n", &h, 99); getchar();
        for (i = 7; i < 28; i++){

          //f,p: count number of cards of each suit (2 octal digits) and rank (1 octal digit.)
          //t: best hand for current 5 cards. g:straight flag. u,w: flags for pairs and 3's.   
          //l: constant 1 (64bit leftshift doesn't work on a literal.) 
          //octal bitmasks: a=ace high straight, b=general purpose

            __int64 f=0,p=0,t=0,g,u,w,l=1,a=01111000000001,b=a+0111111110;

           for (j = 0; j < 7; j++){
               if (j != i %7 & j != (i+i/7) %7){

                   f += l << (strchr(x,h[j*3+1])-x)*6;
                   p += l << (strchr(x,h[j*3])-x-4)*3;

                   printf_s("%c%c ",h[j*3], h[j*3+1]);
               }
           }

           w=p&b*2;                          //if 2nd bit set we have a pair
           if (w) t=1;
           u= w & w-1;                       //if there is only one pair w&w-1 evaluates to 0; +ve for 2 pair.
           if (u) t=2;
           w = p & p/2;                      // if 2nd and 1st bit set we have 3 of kind. 
           if (w) t=3;
           g = p*64 & p*8 & p & p/8 & p/64;  // detects all straights except ace high. pattern for ace high in a.
           if (g||p==a) t=4;
           f&=f*4;                           //for a flush we want 5 cards of the same suit, binary 101
           if (f) t=5;
           if (u&&w) t=6;                    //full house meets conditions of 2 pair and 3 of kind
           if (p & b*4) t=7;                 //four of a kind
           if (f && g) t=8;                  //straight flush
           if (f && p==a) t=9;               //royal flush
           printf_s("%s %s \n",z[t],t>7?z[5]:"");
           q=t>q?t:q;
        }   
        printf_s("%s %s",z[q],q>7?z[5]:"");
        getchar();
}

Sản lượng không mong muốn

perl (> = 5.14), 411 403 400 397 400

Chỉnh sửa : nội tuyến một phụ chỉ được gọi một lần, lưu 8 ký tự.
Chỉnh sửa 2 : xóa một .""cái còn sót lại từ lần thử đầu tiên
Chỉnh sửa 3 : thay vì biến tạm thời giữ nguyên bản gốc $_, sử dụng một biến để làm cho nó không cần thiết. Thu được 3 ký tự.
Chỉnh sửa 4 : lỗi cố định để phát hiện nhà quá đầy đủ (2x 3 loại). Chi phí 3 ký tự.

Không hẳn là một người chiến thắng, nhưng máy dò thẳng là một khái niệm thú vị, tôi nghĩ vậy.

sub
j{join"",sort@_}sub
o{j(map{{A=>10}->{$_},11+index(j(2..9).TJQKA,$_)}$h=~/(.(?=@_))/g)=~/.*(..)(??{j
map$1+$_.'.*',1..4})/?$1:()}$h=$_=<>;if(j(/(\S)\b/g)=~/(.)\1{4}/){$w=$_==19?royal:straight
for
o$f=$1}$_=j(/\b(\S)/g)=~s/(.)\1*/length$&/rge;$k=" of a kind";print$w?"$w flush":/4/?four.$k:/3.*2|[23].*3/?"full house":$f?flush:(o".")?straight:/3/?three.$k:/2.*2/?"two pair":/2/?"one pair":"high card"

Phiên bản mở rộng:

# We'll be doing a lot of sorting and joining
sub j {
  return join "", sort @_;
}

# r() expects $_ to contain a rank, and converts it to a numeric code. The
# code starts at 10 so the numbers will sort correctly as strings, and a list
# of 2 values is returned because A is both 10 and 23. All other ranks have
# undef as the first value and their proper 11..22 value as the second value.
sub r {
  return ({A=>10}->{$_}, 11+index(j(2..9).TJQKA,$_));
}

# Sequence-detector. Factored into a sub because it's run twice; once over
# the ranks in the flush suit to find a straight flush and once over all the
# ranks to find a straight. On successful match, returns the lowest rank of
# the straight (in the 10..23 representation).
# Required parameter: the suit to search, or "." for all suits.
sub o {
  j(map r,$h=~/(.(?=@_))/g)          # The list of ranks, in increasing order,
                                     # with ace included at both ends...
    =~                               # ...is matched against...
  /.*(..)(??{j map$1+$_.'.*',1..4})/ # ...a pattern requiring 5 consecutive
                                     # numbers.
  ?$1:()
  # A note about this regexp. The string we're matching is a bunch of numbers
  # in the range 10..23 crammed together like "121314151619" so you might
  # worry about a misaligned match starting on the second digit of one of the
  # original numbers. But since that would make every pair of digits in the
  # match end with a 1 or a 2, there's no way 5 of them will be consecutive.
  # There are no false matches.
  # Another note: if we have a royal flush and also have a 9 in the same
  # suit, we need to return the T rank, not the 9, which is why the regexp
  # starts with a .*
}

# Read a line into $_ for immediate matching with /.../ and also save it into
# $h because $_ will be clobbered later and we'll need the original string
# afterwards.
$h = $_ = <>;

if(j(/(\S)\b/g) =~ /(.)\1{4}/) { # flush detector: sorted list of all suits
                                 # contains 5 consecutive identical chars
  # $f=$1 comes first, so $f will be true later if there's a flush.
  # Then o() is called with the flush suit as arg to detect straight flush.
  # If there's no straight flush, o() returns the empty list and for loop
  # runs 0 times, so $w is not set. If there is a straight flush, the return
  # value of o() is compared to 19 to detect royal flush.
  $w = ($_==19 ? "royal" : "straight")
    for o($f=$1);
}

$_ =
  j(/\b(\S)/g)                 # Get the sorted+joined list of ranks...
    =~ s/(.)\1*/length $&/rge; # ... and turn it into a list of sizes of
                               # groups of the same rank. The /r flag
                               # requires perl 5.14 or newer.

print
  $w             ? "$w flush" :
  /4/            ? "four of a kind" :
  /3.*2|[23].*3/ ? "full house" :
  $f             ? "flush" :
  (o".")         ? "straight" :
  /3/            ? "three of a kind" :
  /2.*2/         ? "two pair" :
  /2/            ? "one pair" :
                   "high card"

JavaScript 600

sử dụng với nodeJS: node code.js "7H 3S 7S 7D AC QH 7C"

function a(o){s="";for(k in o)s+=o[k];return s}
b=process.argv[2]
c={S:0,H:0,D:0,C:0}
v={A:0,K:0,Q:0,J:0,T:0,"9":0,"8":0,"7":0,"6":0,"5":0,"4":0,"3":0,"2":0}
d=b.split(" ")
for(i=d.length;i--;){e=d[i];c[e[1]]++;v[e[0]]++}
c=a(c);v=a(v)
f=g=h=j=k=l=m=false
if((st=c.indexOf(5))!=-1)g=!g
if(v.match(/[1-9]{5}/))h=!h
if(st==0)f=!f
if(v.indexOf(4)!=-1)j=!j
if(v.indexOf(3)!=-1)k=!k
if(n=v.match(/2/g))if(n)if(n.length>=2)m=!m;else l=!l
p=" of a kind"
q="Flush"
r="Straight"
console.log(f&&g?"Royal "+q:h&&g?r+" "+q:j?"Four"+p:k&&(l||m)?"Full House":g?q:h?r:k?"Three"+p:m?"Two pairs":l?"Pair":"High card")