Dê um nome à mão de pôquer

Dadas cinco cartas, produza o nome da mão de poker, que será uma das seguintes:

High card
One pair
Two pair
Three of a kind
Straight
Flush
Full house
Four of a kind
Straight flush
Royal Flush

Em caso de dúvida, consulte as regras em http://en.wikipedia.org/wiki/List_of_poker_hands .

Entrada

5 cartas dos argumentos stdin ou da linha de comando. Um cartão é uma sequência de duas letras no formulário RS, onde R é a classificação e S é o naipe. As fileiras são 2- 9(cartas numéricas), T(dez), J(Valete), Q(Rainha), K(Rei), A(Ás). Os ternos são S, D, H, Cpara pás, diamantes, corações e clubes, respectivamente.

Exemplo de cartões

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

Exemplo de entrada => saída desejada

3H 5D JS 3C 7C => One pair
JH 4C 2C JD 2H => Two pair
7H 3S 7S 7D 7C => Four of a kind
8C 3H 8S 8H 3S => Full house

Regras

O código mais curto vence

Editar

Parece ótimo até agora! Na verdade, não consigo verificar todas as respostas, pois não conheço muito bem esses idiomas e não tenho compiladores / intérpretes para todos eles, mas suspeito que nem todos tenham pensado que o Ases pode ser o mais alto e o mais importante. as cartas mais baixas de um Straight (flush) .

GolfScript ( 209 208 207 206 200 199 197 196 caracteres)

3/zip:^0={10,''*"TJQKA"+?}/]:?15,{?\{=}+,,}%2,-$6,14.),++@$/):|;[!!2*^1=.&,(!+5+]or{/}*'Full house
Two pair
One pair
ThreeKFourKHigh card
Flush
Straight''K'/' of a kind
'*n/~|1$"Royal"if" "+2$+](=

Estou explorando a liberdade oferecida para ajustar a capitalização: meu Straight Flush e Royal Flush usam maiúsculas Flush para reutilizar a palavra do flush simples.

Nota: algumas versões anteriores eram de buggy: elas só suportavam full house quando o par era de menor valor que o par royal. Eles podem ser corrigidos substituindo o espaço que separa - 0por a $.

Demo

Veio com uma resposta própria :)

Python - 312 301 298

R,K,F,S,g=' 23456789TJQKA2345A',' of a Kind','Flush','Straight ',sorted
s,r=''.join(g(raw_input(),key=R.find)).split()
n,m=g(map(r.count,set(r)))[-2:]
print[[F,[0,'High Card','TOwnoe'[n&1::2]+' Pair',['Full House','Three'+K][n&1],'Four'+K][m]],[[S,'Royal '][r[0]=='T']+F,S]][r in R][len(set(s))>1]

Cria uma lista 2x2 em que os índices das duas dimensões são verificações booleanas de flush e straight. No caso de ambos, verificamos se é um royal flush ou apenas um straight flush. Para não ficar nivelado e não reto, verificamos as outras mãos: men detemos a maior e a segunda maior quantidade de cartas do mesmo valor; os nomes das mãos são armazenados em uma lista com índices de acordo com m. As verificações secundárias dentro dos valores desta lista são feitas npara separar um par de dois pares e três do mesmo tipo da casa.

Edit: Obrigado Nolen Royality por um total de 20 caracteres salvos!

Ruby 1.9 (427 359 348 338 296 292)

EDIT : corrigido para trabalhar com ases baixos.

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

A idéia básica é criar uma matriz da quantidade de cartões em cada classificação, concatenar os dígitos em uma sequência e executar expressões regulares para ver qual o formato da mão. Contamos o número de naipes distintos para determinar se ele deve ser verificado nos diferentes flushes (flush, straight flush, royal flush) ou nas outras formas (tudo o resto).

Aceita os cartões como argumentos de linha de comando separados, da seguinte maneira:

>ruby poker-hand-golf.rb 3H 5D JS 3C 7C
one pair

C, 454 caracteres

#define L for(a=1;a<6;a++)for(b=0;b<13;b++)
#define U u[b+6]
#define R(x,y) if(x)puts(#y);else
b,f,r,h=0,s=0,u[20]={0};main(int a,char**v){L U+=v[a][0]=="23456789TJQKA"[b];f=v[1][1];L{if(v[a][1]!=f)f=0;u[a]+=a==U;if(b>7)h+=U;if(a*13+b<64||!U)r=0;else if(++r==5)s=1;}R(f&&h==25,Royal flush)R(f&&s,Straight flush)R(u[4],Four of a kind)R(u[3]&&u[2],Full house)R(f,Flush)R(s,Straight)R(u[3],Three of a kind)R(u[2]==2,Two pair)R(u[2],One pair)R(h,High card);}

Executar a partir da linha de comando com cartões como argumentos, por exemplo ./a.out 8C 3H 8S 8H 3S

Versão expandida, com comentários:

#define L for(a=1;a<6;a++)for(b=0;b<13;b++)
#define R(x,y) if(x)puts(#y);else
#define U u[b+6]
b,f,r,h=0,s=0,u[20]={0};
main(int a,char**v){
    // card usage - u[6..]
    L U+=v[a][0]=="23456789TJQKA"[b];
    // NOTE: lets expand the inner body of the loop in the answer so this looks more sane:
    // flush
    f=v[1][1];L if(v[a][1]!=f)f=0;
    // count of usages - u[0..5] 
    L u[a]+=a==U;
    // high cards x5
    L if(b>7)h+=U;
    // straights
    L if(a*13+b<64||!U)r=0;else if(++r==5)s=1;        
    // display
    R(f&&h==25,Royal flush)
    R(f&&s,Straight flush)
    R(u[4],Four of a kind)
    R(u[3]&&u[2],Full house)
    R(f,Flush)
    R(s,Straight)
    R(u[3],Three of a kind)
    R(u[2]==2,Two pair)
    R(u[2],One pair)
    R(h,High card);    
}

Edições:

1. Economizou 12 caracteres combinando e reutilizando loops.
2. Salva 9 caracteres, alinhando a constante da string.
3. Salva 19 caracteres usando a stringification em macro, desagradável.

Mathematica , 365

Aqui está minha opinião sobre a resposta de David Carraher.

Mostrado com espaço em branco para facilitar a leitura.

If[
  a = Characters;
  x = Thread;
  r = Range;
  d = Sort[a@StringSplit@# /. x[a@"23456789TJQKA" -> 2~r~14]];
  {t, u} = Sort[Last /@ Tally@#] & /@ x@d;
  c = First /@ d;
  f = u == {5};
  S = "Straight";
  c == r[b = d[[1, 1]], b + 4],
  If[f,
   If[c == 10~r~14, "Royal Flush", S <> " flush"], S],
  If[f, "Flush",
   Switch[t,
    {_, 4},    "Four of a kind",
    {2, 3},    "Full house",
    {__, 3},   "Three of a kind",
    {_, 2, 2}, "Two pair",
    {__, 2},   "One pair",
    _,         "High card"]
  ]
] &

Versão de uma linha:

If[a=Characters;x=Thread;r=Range;d=Sort[a@StringSplit@#/.x[a@"23456789TJQKA"->2~r~14]];{t,u}=Sort[Last/@Tally@#]&/@x@d;c=First/@d;f=u=={5};S="Straight";c==r[b=d[[1,1]],b+4],If[f,If[c==10~r~14,"Royal Flush",S<>" flush"],S],If[f,"Flush",Switch[t,{_,4},"Four of a kind",{2,3},"Full house",{__,3},"Three of a kind",{_,2,2},"Two pair",{__,2},"One pair",_,"High card"]]]&

K, 294 295

d:{F:"Flush";S:"Straight ";P:" Pair";K:" of a kind";$[(f:1=#?,/-1#'c)&("AJKQT")~a@<a:,/j:1#'c:" "\:x;"Royal ",F;f&s:(4#1)~1_-':a@<a:,/(("A23456789TJQKA")!1+!14)@j;S,F;4=p:|/#:'=j;"Four",K;(2;3)~u:a@<a:,/#:'=j;"Full House";f;F;s;S;3=p;"Three",K;(1;2;2)~u;"Two",P;(1;1;1;2)~u;"One",P;"High Card"]}

.

k)d'("TS JS QS KS AS";"3S 4S 5S 7S 6S";"JC JH KS JD JS";"JC JH 2S JD 2C";"2C 9C TC QC 6C";"8C 5D 9H 6C 7D";"8C 8D 9H 8S 7D";"8C 8D 9H 2S 9D";"8C 8D 4H 2S 9D";"3C 8D 4H 2S 9D")
"Royal Flush"
"Straight Flush"
"Four of a kind"
"Full House"
"Flush"
"Straight "
"Three of a kind"
"Two Pair"
"One Pair"
"High Card"

editar: Adicionado 1 caractere para retas Ás-baixas

Python 334 , 326 322 caracteres

p,f,l,t,o=" pair"," of a kind"," Flush","Straight","A23456789TJQK"
v,u=zip(*raw_input().split())
s=''.join(sorted(v,key=o.find))
print{5:"High card",7:"One"+p,9:"Two"+p,11:"Three"+f,13:"Full house",17:"Four"+f,23:t,24:l[1:],25:t,42:t+l,44:"Royal"+l}[(sum(map(v.count,v)),24)[len(set(u))<2]+((0,20)[s=="ATJQK"],18)[s in o]]

Sei que o último liner está ficando bastante ilegível, vou colocar uma versão sem golfe quando estiver satisfeito com minha solução.

GolfScript, 258 250 caracteres

3/zip~;.&,(!\{"23456789TJQKA"?}%$.(\{.@- 8%}%\;"\1"-!\.1/.&{1$\-,}%1.$?)"Four"" of a kind":k+{.,2="Full house"{.2\?)"Three"k+{.3-,({.3\?)"One pair"{;"Straight":?;2$2$&{(8="Royal"?if" flush"+}{;?{"Flush""High card"if}if}if}if}"Two pair"if}if}if}if])\;

O programa espera entrada no STDIN, conforme indicado acima, e sai para STDOUT. Você pode testar o código você mesmo .

> 8C 3H 8S 8H 3S
Full house

> 8C 7H 6S TH 9S
Straight

> AH 3H 4S 2H 6S
High card

Editar: Incorporado sugestões w0lf.

Mathematica - 500 494 465 caracteres

Esta solução é baseada em uma demonstração de poker de Ed Pegg, Jr. Nesta versão, os cartões são tratados internamente como números emRange[2,14]

v[x_] := Block[{d, t, c, f, s},
 d = Sort@ToExpression[Characters[ImportString[x, "Table"][[1]]] /. {"T" -> 10, "J" -> 11, "Q" -> 12, "K" -> 13, "A" -> 14}];t = Sort /@ Map[Length, Split /@ Sort /@ Transpose@d, {2}];c = d[[All, 1]];f = (t[[2]] == {5});s = c == Range[b = d[[1, 1]], b + 4];
If[s,
 If[f, If[c == 10~Range~14, "royal flush", "straight flush"],"straight"],
 If[ f, "flush",
Switch[t[[1]],
 {1, 4}, "four of a kind",
 {2, 3}, "full house",
 {1, 1, 3}, "three of a kind",
 {1, 2, 2}, "two pair",
 {1, 1, 1, 2}, "one pair",
 {1, 1, 1, 1, 1}, "high card"]]]]

Entradas e saídas de amostra:

Notas:

f: nivelado

c: cartas (sem naipe)

s: reto

t: {cartões, suítes}

d: