You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
223 lines
4.3 KiB
223 lines
4.3 KiB
package joker
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// Cards is a slice of Cards.
|
|
type Cards []Card
|
|
|
|
// StandardCards is a slice of standard cards.
|
|
var StandardCards = Cards{
|
|
Card{FaceAce, SuitHearts},
|
|
Card{Face2, SuitHearts},
|
|
Card{Face3, SuitHearts},
|
|
Card{Face4, SuitHearts},
|
|
Card{Face5, SuitHearts},
|
|
Card{Face6, SuitHearts},
|
|
Card{Face7, SuitHearts},
|
|
Card{Face8, SuitHearts},
|
|
Card{Face9, SuitHearts},
|
|
Card{Face10, SuitHearts},
|
|
Card{FaceJack, SuitHearts},
|
|
Card{FaceQueen, SuitHearts},
|
|
Card{FaceKing, SuitHearts},
|
|
Card{FaceAce, SuitDiamonds},
|
|
Card{Face2, SuitDiamonds},
|
|
Card{Face3, SuitDiamonds},
|
|
Card{Face4, SuitDiamonds},
|
|
Card{Face5, SuitDiamonds},
|
|
Card{Face6, SuitDiamonds},
|
|
Card{Face7, SuitDiamonds},
|
|
Card{Face8, SuitDiamonds},
|
|
Card{Face9, SuitDiamonds},
|
|
Card{Face10, SuitDiamonds},
|
|
Card{FaceJack, SuitDiamonds},
|
|
Card{FaceQueen, SuitDiamonds},
|
|
Card{FaceKing, SuitDiamonds},
|
|
Card{FaceAce, SuitClubs},
|
|
Card{Face2, SuitClubs},
|
|
Card{Face3, SuitClubs},
|
|
Card{Face4, SuitClubs},
|
|
Card{Face5, SuitClubs},
|
|
Card{Face6, SuitClubs},
|
|
Card{Face7, SuitClubs},
|
|
Card{Face8, SuitClubs},
|
|
Card{Face9, SuitClubs},
|
|
Card{Face10, SuitClubs},
|
|
Card{FaceJack, SuitClubs},
|
|
Card{FaceQueen, SuitClubs},
|
|
Card{FaceKing, SuitClubs},
|
|
Card{FaceAce, SuitSpades},
|
|
Card{Face2, SuitSpades},
|
|
Card{Face3, SuitSpades},
|
|
Card{Face4, SuitSpades},
|
|
Card{Face5, SuitSpades},
|
|
Card{Face6, SuitSpades},
|
|
Card{Face7, SuitSpades},
|
|
Card{Face8, SuitSpades},
|
|
Card{Face9, SuitSpades},
|
|
Card{Face10, SuitSpades},
|
|
Card{FaceJack, SuitSpades},
|
|
Card{FaceQueen, SuitSpades},
|
|
Card{FaceKing, SuitSpades},
|
|
}
|
|
|
|
func (c Cards) Len() int {
|
|
return len(c)
|
|
}
|
|
|
|
func (c Cards) Less(i, j int) bool {
|
|
return c[i].Value() < c[j].Value()
|
|
}
|
|
|
|
func (c Cards) Swap(i, j int) {
|
|
c[i], c[j] = c[j], c[i]
|
|
}
|
|
|
|
func (c Cards) String() string {
|
|
var s strings.Builder
|
|
for i := range c {
|
|
if i > 0 {
|
|
s.WriteRune(',')
|
|
}
|
|
s.WriteString(c[i].String())
|
|
}
|
|
return s.String()
|
|
}
|
|
|
|
// Copy returns a copy of the supplied cards.
|
|
func (c Cards) Copy() Cards {
|
|
cc := make(Cards, len(c))
|
|
copy(cc, c)
|
|
return cc
|
|
}
|
|
|
|
// Remove returns the supplied cards with the specified card removed one time.
|
|
func (c Cards) Remove(card Card) Cards {
|
|
cc := c.Copy()
|
|
for i, searchCard := range c {
|
|
if searchCard == card {
|
|
return append(cc[:i], cc[i+1:]...)
|
|
}
|
|
}
|
|
return cc
|
|
}
|
|
|
|
// RemoveIndex returns the supplied cards excluding the card at the specified index.
|
|
func (c Cards) RemoveIndex(i int) Cards {
|
|
cc := c.Copy()
|
|
return append(cc[:i], cc[i+1:]...)
|
|
}
|
|
|
|
// Contains returns whether the supplied cards contain the specified card.
|
|
func (c Cards) Contains(card Card) bool {
|
|
for _, compcard := range c {
|
|
if compcard.Equal(card) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Count returns the number of occurrences of the specified card.
|
|
func (c Cards) Count(card Card) int {
|
|
var n int
|
|
for _, compcard := range c {
|
|
if compcard.Equal(card) {
|
|
n++
|
|
}
|
|
}
|
|
|
|
return n
|
|
}
|
|
|
|
// Equal returns whether the supplied cards are equal to another set of cards.
|
|
func (c Cards) Equal(cards Cards) bool {
|
|
if len(c) != len(cards) {
|
|
return false
|
|
}
|
|
|
|
for _, compcard := range c {
|
|
if c.Count(compcard) != cards.Count(compcard) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Sorted returns the supplied cards in order.
|
|
func (c Cards) Sorted() Cards {
|
|
cc := c.Copy()
|
|
sort.Sort(cc)
|
|
return cc
|
|
}
|
|
|
|
// Reversed returns the supplied cards in reverse order.
|
|
func (c Cards) Reversed() Cards {
|
|
l := len(c)
|
|
cc := make(Cards, l)
|
|
for i := 0; i < l; i++ {
|
|
cc[i] = c[l-i-1]
|
|
}
|
|
return cc
|
|
}
|
|
|
|
// Permutations returns all permutations of the supplied cards.
|
|
func (c Cards) Permutations() []Cards {
|
|
var permute func(Cards, int)
|
|
var res []Cards
|
|
permute = func(c Cards, n int) {
|
|
if n == 1 {
|
|
res = append(res, c.Copy())
|
|
} else {
|
|
for i := 0; i < n; i++ {
|
|
permute(c, n-1)
|
|
if n%2 == 1 {
|
|
tmp := c[i]
|
|
c[i] = c[n-1]
|
|
c[n-1] = tmp
|
|
} else {
|
|
tmp := c[0]
|
|
c[0] = c[n-1]
|
|
c[n-1] = tmp
|
|
}
|
|
}
|
|
}
|
|
}
|
|
permute(c, len(c))
|
|
return res
|
|
}
|
|
|
|
// Low returns the lowest valued card.
|
|
func (c Cards) Low() Card {
|
|
if len(c) == 0 {
|
|
return Card{}
|
|
}
|
|
|
|
l := c[0]
|
|
for _, comp := range c[1:] {
|
|
if comp.Value() < l.Value() {
|
|
l = comp
|
|
}
|
|
}
|
|
return l
|
|
}
|
|
|
|
// High returns the highest valued card.
|
|
func (c Cards) High() Card {
|
|
if len(c) == 0 {
|
|
return Card{}
|
|
}
|
|
|
|
h := c[0]
|
|
for _, comp := range c[1:] {
|
|
if comp.Value() > h.Value() {
|
|
h = comp
|
|
}
|
|
}
|
|
return h
|
|
}
|