Poker hand analyser: Difference between revisions
Added FreeBASIC
(→{{header|Raku}}: tweak 'rank' and 'straight' subroutines) |
(Added FreeBASIC) |
||
(5 intermediate revisions by 5 users not shown) | |||
Line 87:
{{trans|D}}
<
V
p1 = 0B
Line 163:
‘4H 4C KC 5D TC’,
‘QC TC 7C 6C 4C’]
print(hand‘: ’analyzeHand(hand))</
{{out}}
Line 179:
=={{header|AutoHotkey}}==
<
StringUpper, hand, hand
Sort, hand, FCardSort D%A_Space%
Line 202:
b := (b = "T") ? 10 : (b = "J") ? 11 : (b = "Q") ? 12 : (b = "K") ? 13 : b
return a > b ? 1 : a < b ? -1 : 0
}</
Examples:<
(join`r`n
2♥ 2♦ 2♣ k♣ q♦
Line 220:
res .= PokerHand(A_LoopField) "`n"
MsgBox, 262144, , % res
return</
Outputs:<pre>2♦ 2♣ 2♥ Q♦ K♣ Three of a Kind
2♥ 5♥ 7♦ 8♣ 9♠ High Card
Line 235:
=={{header|C}}==
{{trans|Kotlin}}
<
#include <ctype.h>
#include <string.h>
Line 363:
}
return 0;
}</
{{output}}
Line 381:
=={{header|C sharp}}==
{{works with|C sharp|8}}
<
using System.Collections.Generic;
using static System.Linq.Enumerable;
Line 542:
}
}</
{{out}}
<pre>
Line 570:
=={{header|C++}}==
<syntaxhighlight lang="cpp">
#include <iostream>
#include <sstream>
Line 645:
cout << p.analyze( "qc tc 7c 6c 4c" ) << endl << endl; return system( "pause" );
}
</syntaxhighlight>
{{out}}
<pre>
Line 660:
=={{header|Clojure}}==
<
(let [[fst _] card]
(if (Character/isDigit fst)
Line 740:
["QC" "TC" "7C" "6C" "4C"]])
(run! println (map #(str % " : " (check-hand %)) hands))
</syntaxhighlight>
{{out}}
Line 759:
No bonus for this simple version.
{{trans|C++}}
<
string analyzeHand(in string inHand) pure /*nothrow @safe*/ {
Line 844:
"QC TC 7C 6C 4C"])
writeln(hand, ": ", hand.analyzeHand);
}</
{{out}}
<pre>2H 2D 2S KS QD: three-of-a-kind
Line 859:
{{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)
Line 985:
best = Enum.map(cards_list, &Hand.new &1) |> Enum.max
IO.puts "#{hand}:\t#{elem(best,3)}"
end)</
{{out}}
Line 1,022:
=={{header|F Sharp|F#}}==
<
type Card = int * int
Line 1,122:
]
|> List.iter showHandRank
</syntaxhighlight>
{{out}}
Line 1,152:
=={{header|Factor}}==
Factor comes with a poker hand evaluator.
<
{
"2H 2D 2C KC QD"
Line 1,163:
"4H 4S KS 5D TS"
"QC TC 7C 6C 4C"
} [ dup string>hand-name "%s: %s\n" printf ] each</
{{out}}
<pre>
Line 1,176:
QC TC 7C 6C 4C: Flush
</pre>
=={{header|FreeBASIC}}==
{{trans|C}}
<syntaxhighlight lang="vbnet">Const As String FACES = "23456789tjqka"
Const As String SUITS = "shdc"
Type card
face As Integer ' FACES map to 0..12 respectively
suit As String
End Type
Dim Shared As card cards(4)
Sub insertionSort(arr() As card, Byval n As Integer)
Dim As Integer i, key, j
For i = 1 To n-1
key = arr(i).face
j = i-1
While j >= 0 And arr(j).face > key
arr(j+1) = arr(j)
j = j-1
Wend
arr(j+1).face = key
Next i
End Sub
Function compareCard(Byval a As card, Byval b As card) As Integer
Return a.face - b.face
End Function
Function equalsCard(Byval c1 As card, Byval c2 As card) As Integer
If c1.face = c2.face And c1.suit = c2.suit Then Return True
Return False
End Function
Function areDistinct() As Integer
Dim As Integer i, j
For i = 0 To 3
For j = i + 1 To 4
If equalsCard(cards(i), cards(j)) = True Then Return False
Next j
Next i
Return True
End Function
Function isStraight() As Boolean
insertionSort(cards(), 5)
If cards(0).face + 4 = cards(4).face Then Return True
If cards(4).face = 12 And cards(0).face = 0 And cards(3).face = 3 Then Return True
Return False
End Function
Function isFlush() As Boolean
Dim As String suit = cards(0).suit
For i As Integer = 1 To 4
If cards(i).suit <> suit Then Return False
Next i
Return True
End Function
Function analyzeHand(Byval hand As String) As String
Dim As Integer i, j, cp, gs = 0
Dim As String suit
Dim As Integer found, flush, straight
Dim As Integer groups(12)
If Len(hand) <> 14 Then Return "invalid"
For i = 0 To 13 Step 3
cp = Instr(FACES, Lcase(Mid(hand, i + 1, 1)))
If cp = 0 Then Return "invalid"
j = i \ 3
cards(j).face = cp - 1
suit = Lcase(Mid(hand, i + 2, 1))
cp = Instr(SUITS, suit)
If cp = 0 Then Return "invalid"
cards(j).suit = suit
Next i
If areDistinct() = False Then Return "invalid"
For i = 0 To 12
groups(i) = 0
Next i
For i = 0 To 4
groups(cards(i).face) += 1
Next i
For i = 0 To 12
If groups(i) > 0 Then gs += 1
Next i
Select Case gs
Case 2
found = False
For i = 0 To 12
If groups(i) = 4 Then
found = True
Exit For
End If
Next i
If found = True Then Return "four-of-a-kind"
Return "full-house"
Case 3
found = False
For i = 0 To 12
If groups(i) = 3 Then
found = True
Exit For
End If
Next i
If found = True Then Return "three-of-a-kind"
Return "two-pairs"
Case 4
Return "one-pair"
Case Else
flush = isFlush()
straight = isStraight()
If flush = True And straight = True Then
Return "straight-flush"
Elseif flush = True Then
Return "flush"
Elseif straight = True Then
Return "straight"
Else
Return "high-card"
End If
End Select
End Function
Dim As String tipo
Dim As String hands(9) = { _
"2h 2d 2c kc qd", _
"2h 5h 7d 8c 9s", _
"ah 2d 3c 4c 5d", _
"2h 3h 2d 3c 3d", _
"2h 7h 2d 3c 3d", _
"2h 7h 7d 7c 7s", _
"th jh qh kh ah", _
"4h 4s ks 5d ts", _
"qc tc 7c 6c 4c", _
"ah ah 7c 6c 4c" }
For i As Integer = 0 To 9
tipo = analyzeHand(hands(i))
Print hands(i); ": "; tipo
Next i
Sleep</syntaxhighlight>
{{out}}
<pre>Same as C entry.</pre>
=={{header|Go}}==
{{trans|Kotlin}}
===Basic Version===
<
import (
Line 1,305 ⟶ 1,451:
fmt.Printf("%s: %s\n", hand, analyzeHand(hand))
}
}</
{{out}}
Line 1,322 ⟶ 1,468:
===Extra Credit Version===
<
import (
Line 1,537 ⟶ 1,683:
fmt.Printf("%s: %s\n", hand, analyzeHand(hand))
}
}</
{{out}}
Line 1,560 ⟶ 1,706:
=={{header|Haskell}}==
===Basic Version===
<
import Data.Function (on)
Line 1,654 ⟶ 1,800:
main :: IO ()
main = mapM_ (putStrLn . (fst <> const ": " <> nameHand . snd)) testHands</
{{out}}
<pre>2♥ 2♦ 2♣ k♣ q♦: Three of a kind
Line 1,670 ⟶ 1,816:
=={{header|J}}==
<
Suits=: <"> 7 u: '♥♦♣♦' NB. or Suits=: 'hdcs'
Faces=: <;._1 ' 2 3 4 5 6 7 8 9 10 j q k a'
Line 1,705 ⟶ 1,851:
('straight-flush' IF (straight * flush)) Or
('five-of-a-kind' IF five)
)
Hands=: <@deb;._2 {{)n
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♠
q♣ 10♣ 7♣ 6♣ 4♣
}}</syntaxhighlight>
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
</pre>
Output for extra-credit examples
Line 1,740 ⟶ 1,899:
{{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;
Line 1,919 ⟶ 2,078:
}
}
}</
{{out}}
Line 1,969 ⟶ 2,128:
=={{header|JavaScript}}==
{{works with|JavaScript|ECMAScript 6}}
<
const SUITS = ['♥', '♦', '♣', '♠'];
Line 1,999 ⟶ 2,158:
else if (groups[0] === 2) return 'one-pair'
else return 'high-card';
}</
Demonstrating:
<
"2♥ 2♦ 2♣ k♣ q♦",
"2♥ 5♥ 7♦ 8♣ 9♠",
Line 2,020 ⟶ 2,179:
];
for(hand of testHands) console.log(hand + ": " + analyzeHand(hand));</
{{out}}
<pre>
Line 2,042 ⟶ 2,201:
=={{header|Julia}}==
<
cardlessthan(card1, card2) = indexin(x, sorteddeck)[1] < indexin(y, sorteddeck)[1]
Line 2,162 ⟶ 2,321:
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.
Line 2,179 ⟶ 2,338:
=={{header|Kotlin}}==
===Basic Version===
<
class Card(val face: Int, val suit: Char)
Line 2,254 ⟶ 2,413:
println("$hand: ${analyzeHand(hand)}")
}
}</
{{out}}
Line 2,271 ⟶ 2,430:
===Extra Credit Version===
<
class Card(val face: Int, val suit: Char)
Line 2,398 ⟶ 2,557:
println("$hand : ${analyzeHand(hand)}")
}
}</
{{out}}
Line 2,420 ⟶ 2,579:
=={{header|Lua}}==
<
function valid (t)
if #t ~= 5 then return false end
Line 2,542 ⟶ 2,701:
"qc 10c 7c 6c 4c" -- flush
}
for _, case in pairs(testCases) do print(case, ": " .. rank(case)) end</
{{out}}
<pre>2h 2d 2c kc qd : three-of-a-kind
Line 2,555 ⟶ 2,714:
=={{header|Nim}}==
<
type
Line 2,678 ⟶ 2,837:
for handString in HandStrings:
let hand = handString.split(' ').map(toCard)
echo hand.map(`$`).join(" "), " → ", hand.value</
{{out}}
Line 2,695 ⟶ 2,854:
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;
Line 2,838 ⟶ 2,997:
say Hand::describe($_) for @cards;
</syntaxhighlight>
{{out}}
<pre>
Line 2,867 ⟶ 3,026:
{{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>
Line 2,964 ⟶ 3,123:
<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>
Line 2,992 ⟶ 3,151:
=={{header|Picat}}==
<
Hands = [
[[2,h], [7,h], [2,d], [3,c], [3,d]], % two-pair
Line 3,139 ⟶ 3,298:
% high card
analyse1(_Hand,Value) =>
Value = high_card.</
Line 3,181 ⟶ 3,340:
For generating and checking random hands:
<
_ = random2(),
Hand = random_hand(5),
Line 3,200 ⟶ 3,359:
M.put([oneof(Faces),oneof(Suites)],1)
end,
Hand = [C : C=_ in M].sort().</
{{out}}
Line 3,209 ⟶ 3,368:
=={{header|PicoLisp}}==
(rassoc) function in picolisp after 3.1.9.10.
<
'(("2" . 0) ("3" . 1) ("4" . 2)
("5" . 3) ("6" . 4) ("7" . 5)
Line 3,244 ⟶ 3,403:
'two-pair )
((rassoc 2 R) 'pair)
(T 'high-card) ) ) )</
=={{header|Prolog}}==
{{works with|GNU Prolog|1.4.4}}
Not very efficient version.
<
Line 3,319 ⟶ 3,478:
, write(Cards), write('\t'), write(H), nl
.
main :- findall(_, run_tests, _), halt.</
{{out}}
<pre>[c(2,♥),c(2,♦),c(2,♣),c(k,♣),c(q,♦)] three-of-a-kind(2)
Line 3,333 ⟶ 3,492:
=={{header|Python}}==
Goes a little further in also giving the ordered tie-breaker information from the wikipedia page.
<
class Card(namedtuple('Card', 'face, suit')):
Line 3,482 ⟶ 3,641:
for cards in hands:
r = rank(cards)
print("%-18r %-15s %r" % (cards, r[0], r[1]))</
{{out}}
<pre>HAND CATEGORY TIE-BREAKER
Line 3,496 ⟶ 3,655:
=={{header|Racket}}==
<
(require (only-in srfi/1 car+cdr))
Line 3,660 ⟶ 3,819:
(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)))
(for ((h e.g.-hands) (r expected-results)) (check-equal? (analyse-hand/string h) r)))</
{{out}}
Line 3,690 ⟶ 3,849:
(formerly Perl 6)
This solution handles jokers. It has been written to use a Raku grammar.
<syntaxhighlight lang="raku"
grammar PokerHand {
Line 3,799 ⟶ 3,958:
say "$_: $rank";
}
</syntaxhighlight>
{{out}}
<pre>2♥ 2♦ 2♣ k♣ q♦: three-of-a-kind
Line 3,827 ⟶ 3,986:
=={{header|REXX}}==
===version 1===
<
* 10.12.2013 Walter Pachl
*--------------------------------------------------------------------*/
Line 3,924 ⟶ 4,083:
err:
Say deck 'Error:' arg(1)
Return 0</
{{out}}
<pre>2h 2d 2s ks qd three-of-a-kind
Line 3,950 ⟶ 4,109:
::* the dealt hands can be in a file (blank lines are ignored)
::* 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. */
Line 3,989 ⟶ 4,148:
if kinds==2 & pairs==2 then return 'two-pair'
if kinds==2 then return 'one-pair'
return 'high-card'</
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= file:}}
Line 4,028 ⟶ 4,187:
::* supports up to two ''jokers''
::* 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'
Line 4,086 ⟶ 4,245:
if kinds==2 & pairs==2 then return 'two-pair'
if kinds==2 then return 'one-pair'
return 'high-card'</
Programming note: the method used for analyzing hands that contain jokers are limited to a maximum of two jokers.
Line 4,140 ⟶ 4,299:
q♣ t♣ 7♣ 6♣ jok ◄─── flush
J♥ Q♦ K♠ A♠ jok ◄─── straight
</pre>
=={{header|RPL}}==
{{works with|HP|48G}}
≪ → hand
≪ { }
1 15 '''FOR''' j
"A23456789TJQK" hand j DUP SUB POS 1 -
"CDHS" hand j 1 + DUP SUB POS 13 * +
+ 3 '''STEP'''
≫ ≫ '<span style="color:blue>HANDCODE</span>' STO
≪ → diffs
≪ { } 1
1 4 '''FOR''' j
'''IF''' diffs j GET '''THEN''' + 1 '''ELSE''' 1 + '''END NEXT'''
+ SORT REVLIST 1 2 SUB
≫ ≫ '<span style="color:blue>GROUPS</span>' STO
≪ DUP ΠLIST 1 ==
SWAP { 9 1 1 1 } 1 == OR
≫ '<span style="color:blue>STRAIGHT?</span>' STO
≪ <span style="color:blue>HANDCODE</span>
DUP 13 / IP ≪ == ≫ DOSUBS ΠLIST
SWAP 13 MOD SORT ΔLIST
DUP <span style="color:blue>GROUPS</span> SWAP <span style="color:blue>STRAIGHT?</span>
→ flush groups straight
≪ '''CASE'''
straight '''THEN''' flush "Straight flush" "Straight" IFTE '''END'''
groups { 4 1 } == '''THEN''' "Four of a kind" '''END'''
groups { 3 2 } == '''THEN''' "Full house" '''END'''
groups { 3 1 } == '''THEN''' "Three of a kind" '''END'''
groups { 2 2 } == '''THEN''' "Two pairs" '''END'''
groups { 2 1 } == '''THEN''' "One pair" '''END'''
flush "Flush" "High card" IFTE '''END'''
≫ ≫ '<span style="color:blue>→HAND</span>' STO
{ "2H 2D 2S KS QD" "2H 5H 7D 8S 9D" "AH 2D 3S 4S 5S" "2H 3H 2D 3S 3D" "2H 7H 2D 3S 3D" "2H 7H 7D 7S 7C" "TH JH QH KH AH" "4H 4C KC 5D TC" "QC TC 7C 6C 4C" }
1 ≪ <span style="color:blue>→HAND</span> ≫ DOLIST
{{out}}
<pre>
1: { "Three of a kind" "High card" "Straight" "Full house" "Two pairs" "Four of a kind" "Straight flush" "One pair" "Flush" }
</pre>
=={{header|Ruby}}==
Joker-less hands are sorted high to low.
<
include Comparable
attr_accessor :ordinal
Line 4,287 ⟶ 4,489:
best = all_tries.max
puts "#{line.strip}: #{best.rank}"
end</
{{out}}
Line 4,324 ⟶ 4,526:
=={{header|Rust}}==
Unicode version with jokers. Also checks for Royal Flush (AKQJ10 suited).
<syntaxhighlight lang="rust">
fn main() {
let hands = vec![
Line 4,433 ⟶ 4,635:
(face, suit)
}
</syntaxhighlight>
{{out}}
<pre>
Line 4,456 ⟶ 4,658:
=={{header|Scala}}==
Including jokers, but not special suit characters. Aiming for readability more than performance.
<
val suits = "CHSD"
sealed trait Card
Line 4,529 ⟶ 4,731:
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",
Line 4,556 ⟶ 4,758:
for (hand <- testHands) {
println(s"$hand -> ${analyzeHand(parseHand(hand))}")
}</
{{out}}
Line 4,582 ⟶ 4,784:
=={{header|Seed7}}==
<
include "console.s7i";
Line 4,656 ⟶ 4,858:
analyze("4♥ 4♣ k♣ 5♦ t♣");
analyze("q♣ t♣ 7♣ 6♣ 4♣");
end func;</
{{out}}
Line 4,672 ⟶ 4,874:
=={{header|Standard ML}}==
<syntaxhighlight lang="standard ml">
local
val rec ins = fn x : int*'a => fn [] => [x]
Line 4,736 ⟶ 4,938:
end;
</syntaxhighlight>
Example (interpreter):
<syntaxhighlight lang="standard ml">
val rec printio = fn
[] => ()
Line 4,766 ⟶ 4,968:
ac ah ac ad 10h : invalid
val it = (): unit
</syntaxhighlight>
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<
namespace eval PokerHandAnalyser {
proc analyse {hand} {
Line 4,885 ⟶ 5,087:
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♠"
Line 4,893 ⟶ 5,095:
} {
puts "${hand}: [PokerHandAnalyser::analyse $hand]"
}</
{{out}}
<pre>
Line 4,907 ⟶ 5,109:
</pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
option explicit
class playingcard
dim suit
dim pips
'public property get gsuit():gsuit=suit:end property
'public property get gpips():gpips=pips:end property
public sub print
dim s,p
select case suit
case "S":s=chrW(&h2660)
case "D":s=chrW(&h2666)
case "C":s=chrW(&h2663)
case "H":s=chrW(&h2665)
end select
select case pips
case 1:p="A"
case 11:p="J"
case 12:p="Q"
case 13:p="K"
case else: p=""& pips
end select
wscript.stdout.write right(" "&p & s,3)&" "
end sub
end class
sub printhand(byref h,start)
dim i
for i =start to ubound(h)
h(i).print
next
'wscript.stdout.writeblanklines(1)
end sub
function checkhand(byval arr)
dim ss,i,max,last,uses,toppip,j,straight, flush,used,ace
redim nn(13)
ss=arr(0).suit '?????
straight=true:flush=true
max=0:last=0:used=0:toppip=0:ace=0
for i=0 to ubound(arr)
j=arr(i).pips
if arr(i).suit<>ss then flush=false
if j>toppip then toppip=j
if j=1 then ace=1
nn(j)=nn(j)+1
if nn(j)>max then max= nn(j)
if abs(j-toppip)>=4 then straight=0
next
for i=1 to ubound(nn)
if nn(i) then used=used+1
next
if max=1 then
if nn(1) and nn(10) and nn(11) and nn(12) and nn(13) then straight=1
end if
if flush and straight and max=1 then
checkhand= "straight-flush"
elseif flush then
checkhand= "flush"
elseif straight and max=1 then
checkhand= "straight"
elseif max=4 then
checkhand= "four-of-a-kind"
elseif max=3 then
if used=2 then
checkhand= "full-house"
else
checkhand= "three-of-a-kind"
end if
elseif max=2 then
if used=3 then
checkhand= "two-pair"
else
checkhand= "one-pair"
end if
else
checkhand= "Top "& toppip
End If
end function
function readhand(h)
dim i,b,c,p
redim a(4)
for i=0 to ubound(a)
b=h(i)
set c=new playingcard
p=left(b,1)
select case p
case "j": c.pips=11
case "q": c.pips=12
case "k": c.pips=13
case "t": c.pips=10
case "a": c.pips=1
case else c.pips=cint(p)
end select
c.suit=ucase(right(b,1))
set a(i)=c
next
readhand=a
erase a
end function
dim hands,hh,i
hands = Array(_
Array("2h", "5h", "7d", "8c", "9s"),_
Array("2h", "2d", "2c", "kc", "qd"),_
Array("ah", "2d", "3c", "4c", "5d"),_
Array("2h", "3h", "2d", "3c", "3d"),_
Array("2h", "7h", "2d", "3c", "3d"),_
Array("th", "jh", "qh", "kh", "ah"),_
Array("4h", "4s", "ks", "5d", "ts"),_
Array("qc", "tc", "7c", "6c", "4c"),_
Array("ah", "ah", "7c", "6c", "4c"))
for i=1 to ubound(hands)
hh=readhand(hands(i))
printhand hh,0
wscript.stdout.write vbtab & checkhand(hh)
wscript.stdout.writeblanklines(1)
'exit for
next
</syntaxhighlight>
{{out}}
<pre>
2♥ 2♦ 2♣ K♣ Q♦ three-of-a-kind
A♥ 2♦ 3♣ 4♣ 5♦ straight
2♥ 3♥ 2♦ 3♣ 3♦ full-house
2♥ 7♥ 2♦ 3♣ 3♦ two-pair
10♥ J♥ Q♥ K♥ A♥ straight-flush
4♥ 4♠ K♠ 5♦ 10♠ one-pair
Q♣ 10♣ 7♣ 6♣ 4♣ flush
A♥ A♥ 7♣ 6♣ 4♣ one-pair
</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
Line 4,914 ⟶ 5,255:
{{libheader|Wren-seq}}
===Basic Version===
<
import "./sort" for Sort
import "./str" for Str
import "./seq" for Lst
var Card = Tuple.create("Card", ["face", "suit"])
Line 4,984 ⟶ 5,325:
for (hand in hands) {
System.print("%(hand): %(analyzeHand.call(hand))")
}</
{{out}}
Line 5,000 ⟶ 5,341:
</pre>
===Extra Credit Version===
<
import "./sort" for Sort
import "./seq" for Lst
var Card = Tuple.create("Card", ["face", "suit"])
Line 5,113 ⟶ 5,454:
for (hand in hands) {
System.print("%(hand): %(analyzeHand.call(hand))")
}</
{{out}}
|