Poker hand analyser: Difference between revisions

{{trans|D}}

 

V

p1 = 0B

‘4H 4C KC 5D TC’,

‘QC TC 7C 6C 4C’]

 

{{out}}

 

=={{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>

{{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}}

=={{header|Haskell}}==

===Basic Version===

 

import Data.Function (on)

 

main :: IO ()

{{out}}

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

=={{header|J}}==

 

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

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

4♥ 4♠ k♠ 5♦ 10♠

q♣ 10♣ 7♣ 6♣ 4♣

 

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).

{{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

 

=={{header|Nim}}==

 

type

for handString in HandStrings:

let hand = handString.split(' ').map(toCard)

 

{{out}}

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>

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/poker_hand.htm here].

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">poker</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">hand</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d. %s %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">11</span><span style="color: #0000FF;">-</span><span style="color: #000000;">rank</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hand</span><span style="color: #0000FF;">,</span><span style="color: #000000;">desc</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|Picat}}==

Hands = [

[[2,h], [7,h], [2,d], [3,c], [3,d]], % two-pair

% high card

analyse1(_Hand,Value) =>

 

 

 

For generating and checking random hands:

_ = random2(),

Hand = random_hand(5),

M.put([oneof(Faces),oneof(Suites)],1)

end,

 

{{out}}

=={{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 {

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.

 

=={{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}}

=={{header|Rust}}==

Unicode version with jokers. Also checks for Royal Flush (AKQJ10 suited).

fn main() {

let hands = vec![

(face, suit)

}

{{out}}

<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>

 

=={{header|VBScript}}==

option explicit

class playingcard

next

 

{{out}}

<pre>

{{libheader|Wren-seq}}

===Basic Version===

import "/sort" for Sort

import "/str" for Str

for (hand in hands) {

System.print("%(hand): %(analyzeHand.call(hand))")

 

{{out}}

</pre>

===Extra Credit Version===

import "/sort" for Sort

import "/seq" for Lst

for (hand in hands) {

System.print("%(hand): %(analyzeHand.call(hand))")

 

{{out}}