Poker hand analyser: Difference between revisions

A poker hand is specified as a space separated list of five playing cards.

 

 

 

 

Duplicate cards are illegal.

invalid

 

 

The programs output for the above examples should be displayed here on this page.

# use the playing card characters introduced with Unicode 6.0 (U+1F0A1 - U+1F0DE).

# allow two jokers

::* duplicates would be allowed (for jokers only)

::* five-of-a-kind would then be the highest hand

 

;More extra credit examples:

<br><br>

 

=={{header|AutoHotkey}}==

StringUpper, hand, hand

Sort, hand, FCardSort D%A_Space%

b := (b = "T") ? 10 : (b = "J") ? 11 : (b = "Q") ? 12 : (b = "K") ? 13 : b

return a > b ? 1 : a < b ? -1 : 0

(join`r`n

2♥ 2♦ 2♣ k♣ q♦

res .= PokerHand(A_LoopField) "`n"

MsgBox, 262144, , % res

Outputs:<pre>2♦ 2♣ 2♥ Q♦ K♣ Three of a Kind

2♥ 5♥ 7♦ 8♣ 9♠ High Card

=={{header|C}}==

{{trans|Kotlin}}

#include <ctype.h>

#include <string.h>

}

return 0;

 

{{output}}

=={{header|C sharp}}==

{{works with|C sharp|8}}

using System.Collections.Generic;

using static System.Linq.Enumerable;

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

#include <sstream>

cout << p.analyze( "qc tc 7c 6c 4c" ) << endl << endl; return system( "pause" );

}

{{out}}

<pre>

 

=={{header|Clojure}}==

(let [[fst _] card]

(if (Character/isDigit fst)

["QC" "TC" "7C" "6C" "4C"]])

(run! println (map #(str % " : " (check-hand %)) hands))

 

{{out}}

No bonus for this simple version.

{{trans|C++}}

 

string analyzeHand(in string inHand) pure /*nothrow @safe*/ {

"QC TC 7C 6C 4C"])

writeln(hand, ": ", hand.analyzeHand);

{{out}}

<pre>2H 2D 2S KS QD: three-of-a-kind

{{trans|Ruby}}

{{works with|Elixir|1.2}}

@faces ~w(2 3 4 5 6 7 8 9 10 j q k a)

@suits ~w(♥ ♦ ♣ ♠) # ~w(h d c s)

best = Enum.map(cards_list, &Hand.new &1) |> Enum.max

IO.puts "#{hand}:\t#{elem(best,3)}"

 

{{out}}

 

=={{header|F Sharp|F#}}==

type Card = int * int

 

]

|> List.iter showHandRank

 

{{out}}

=={{header|Factor}}==

Factor comes with a poker hand evaluator.

{

"2H 2D 2C KC QD"

"4H 4S KS 5D TS"

"QC TC 7C 6C 4C"

{{out}}

<pre>

QC TC 7C 6C 4C: Flush

</pre>

 

=={{header|Go}}==

{{trans|Kotlin}}

===Basic Version===

 

import (

fmt.Printf("%s: %s\n", hand, analyzeHand(hand))

}

 

{{out}}

 

===Extra Credit Version===

 

import (

fmt.Printf("%s: %s\n", hand, analyzeHand(hand))

}

 

{{out}}

🃂 🃞 🃍 🃁 🃊 : high-card

</pre>

 

=={{header|J}}==

 

Suits=: <"> 7 u: '♥♦♣♦' NB. or Suits=: 'hdcs'

Faces=: <;._1 ' 2 3 4 5 6 7 8 9 10 j q k a'

('straight-flush' IF (straight * flush)) Or

('five-of-a-kind' IF five)

 

Note that * acts as "logical and" on logical values (if you need to deal with boolean values in the original sense - which were not constrained to logical values - you should use *. instead of * to achieve boolean multiplication, but that's not needed here).

 

 

 

Output for extra-credit examples

{{works with|Java|7}}

This code does not qualify for extra credit. Although it supports wildcards, it does not allow for duplicates.

import java.util.Collections;

import java.util.HashSet;

}

}

 

{{out}}

=={{header|JavaScript}}==

{{works with|JavaScript|ECMAScript 6}}

const SUITS = ['♥', '♦', '♣', '♠'];

 

else if (groups[0] === 2) return 'one-pair'

else return 'high-card';

Demonstrating:

"2♥ 2♦ 2♣ k♣ q♦",

"2♥ 5♥ 7♦ 8♣ 9♠",

];

{{out}}

<pre>

 

=={{header|Julia}}==

 

cardlessthan(card1, card2) = indexin(x, sorteddeck)[1] < indexin(y, sorteddeck)[1]

println("Hand $hand is a ", scorehand(hand), " hand.")

end

Hand ["2♥", "2♦", "2♣", "K♣", "Q♦"] is a three-of-a-kind hand.

Hand ["2♥", "5♥", "7♦", "8♣", "9♠"] is a high-card hand.

 

 

 

 

=={{header|Kotlin}}==

===Basic Version===

 

class Card(val face: Int, val suit: Char)

println("$hand: ${analyzeHand(hand)}")

}

 

{{out}}

 

===Extra Credit Version===

 

class Card(val face: Int, val suit: Char)

println("$hand : ${analyzeHand(hand)}")

}

 

{{out}}

 

=={{header|Lua}}==

function valid (t)

if #t ~= 5 then return false end

"qc 10c 7c 6c 4c" -- flush

}

{{out}}

<pre>2h 2d 2c kc qd : three-of-a-kind

4h 4s ks 5d 10s : one-pair

qc 10c 7c 6c 4c : flush</pre>

 

=={{header|Perl}}==

I dont like jokers. Instead I decided to give hands proper names. For example, "Kings full of Tens" rather than just "full-house".

 

use strict;

use warnings;

say Hand::describe($_) for @cards;

{{out}}

<pre>

Note: I have left a copy of this in demo\HelloUTF8.exw to prove it works, but non-ascii on a Windows

console is not Phix's forte.<br>

{{out}}

<pre>

</pre>

 

=={{header|PicoLisp}}==

(rassoc) function in picolisp after 3.1.9.10.

'(("2" . 0) ("3" . 1) ("4" . 2)

("5" . 3) ("6" . 4) ("7" . 5)

'two-pair )

((rassoc 2 R) 'pair)

 

=={{header|Prolog}}==

{{works with|GNU Prolog|1.4.4}}

Not very efficient version.

 

 

, write(Cards), write('\t'), write(H), nl

.

{{out}}

<pre>[c(2,♥),c(2,♦),c(2,♣),c(k,♣),c(q,♦)] three-of-a-kind(2)

=={{header|Python}}==

Goes a little further in also giving the ordered tie-breaker information from the wikipedia page.

 

class Card(namedtuple('Card', 'face, suit')):

for cards in hands:

r = rank(cards)

{{out}}

<pre>HAND CATEGORY TIE-BREAKER

 

=={{header|Racket}}==

(require (only-in srfi/1 car+cdr))

 

(five-of-a-kind 7) (straight-flush 14) (one-pair 13 10 5 4) (flush 14 13 7 6 4) (straight 6)

(straight 14) (straight-flush 14) (four-of-a-kind 2)))

 

{{out}}

(formerly Perl 6)

This solution handles jokers. It has been written to use a Raku grammar.

grammar PokerHand {

method TOP($/) {

my UInt @n = n-of-a-kind($/);

make rank(@n[0], @n[1], $flush, $straight);

}

sub n-of-a-kind($/) {

# allow both ace-low and ace-high straights

constant @Faces = [ "a 2 3 4 5 6 7 8 9 10 j q k a".split: ' ' ];

 

my $faces = set @<face-card>.map: -> $/ {~$<face>.lc};

say "$_: $rank";

}

{{out}}

<pre>2♥ 2♦ 2♣ k♣ q♦: three-of-a-kind

=={{header|REXX}}==

===version 1===

* 10.12.2013 Walter Pachl

*--------------------------------------------------------------------*/

err:

Say deck 'Error:' arg(1)

{{out}}

<pre>2h 2d 2s ks qd three-of-a-kind

::* &nbsp; the dealt hands can be in a file &nbsp; (blank lines are ignored)

::* &nbsp; dealt hands in the file can have comments after a semicolon (''';''')

parse arg iFID .; if iFID=='' | iFID=="," then iFID= 'POKERHAN.DAT'

/* [↓] read the poker hands dealt. */

if kinds==2 & pairs==2 then return 'two-pair'

if kinds==2 then return 'one-pair'

Programming note: some older REXXes don't have the '''countstr''' BIF, so that REXX statement (above, line '''48''') can be replaced with:

 

{{out|input|text=&nbsp; file:}}

::* &nbsp; supports up to two ''jokers''

::* &nbsp; the ''joker'' card may be abbreviated (and can be in upper/lower/mixed case)

/*──────────────────────────────────────────── poker hands may contain up to two jokers.*/

parse arg iFID .; if iFID=='' | iFID=="," then iFID= 'POKERHAJ.DAT'

if kinds==2 & pairs==2 then return 'two-pair'

if kinds==2 then return 'one-pair'

Programming note: &nbsp; the method used for analyzing hands that contain jokers are limited to a maximum of two jokers.

 

q♣ t♣ 7♣ 6♣ jok ◄─── flush

J♥ Q♦ K♠ A♠ jok ◄─── straight

</pre>

 

=={{header|Ruby}}==

Joker-less hands are sorted high to low.

include Comparable

attr_accessor :ordinal

best = all_tries.max

puts "#{line.strip}: #{best.rank}"

 

{{out}}

joker Q♦ joker A♦ 10♦: straight-flush

joker 2♦ 2♠ joker q♦: four-of-a-kind

</pre>

 

=={{header|Scala}}==

Including jokers, but not special suit characters. Aiming for readability more than performance.

val suits = "CHSD"

sealed trait Card

val possibleHands = possibleRealHands(hand)

allHandTypes.find(t => possibleHands.exists(t.check)).map(_.name).getOrElse("high-card")

 

"2H 2D 2S KS QD",

"2H 5H 7D 8S 9D",

for (hand <- testHands) {

println(s"$hand -> ${analyzeHand(parseHand(hand))}")

 

{{out}}

 

=={{header|Seed7}}==

include "console.s7i";

 

analyze("4♥ 4♣ k♣ 5♦ t♣");

analyze("q♣ t♣ 7♣ 6♣ 4♣");

 

{{out}}

 

=={{header|Standard ML}}==

local

val rec ins = fn x : int*'a => fn [] => [x]

end;

Example (interpreter):

val rec printio = fn

[] => ()

ac ah ac ad 10h : invalid

val it = (): unit

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

namespace eval PokerHandAnalyser {

proc analyse {hand} {

return 0

}

Demonstrating:

"2♥ 2♦ 2♣ k♣ q♦" "2♥ 5♥ 7♦ 8♣ 9♠" "a♥ 2♦ 3♣ 4♣ 5♦" "2♥ 3♥ 2♦ 3♣ 3♦"

"2♥ 7♥ 2♦ 3♣ 3♦" "2♥ 7♥ 7♦ 7♣ 7♠" "10♥ j♥ q♥ k♥ a♥" "4♥ 4♠ k♠ 5♦ 10♠"

} {

puts "${hand}: [PokerHandAnalyser::analyse $hand]"

{{out}}

<pre>

4♥ 4♠ k♠ 5♦ 10♠: one-pair

q♣ 10♣ 7♣ 6♣ 4♣: flush

</pre>